by griddynamics
Meta-prompting, context engineering, and centralized instructions management for AI coding agents
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
# Add to your Claude Code skills
git clone https://github.com/griddynamics/rosettaNo comments yet. Be the first to share your thoughts!
Rosetta is a meta-prompting, context engineering, and centralized instructions management for AI coding agents. It provides structured context - rules, skills, workflows, and sub-agents - guiding AI systems to operate with a deep understanding of system architecture, domain constraints, and engineering standards. Rosetta also accelerates project onboarding by reverse-engineering architecture and domain context, improving the reliability and consistency of AI-generated code.
Every AI interaction follows four phases: Prepare (load guardrails and context), Research (search the knowledge base), Plan (produce a reviewable plan), Act (execute with full context). Read more in the Usage Guide.
Cursor | Claude Code | VS Code / GitHub Copilot | JetBrains (Copilot, Junie) | Windsurf | Codex | Antigravity | OpenCode | Gemini CLI
Works with any MCP-compatible coding agent, though plugins are recommended.
| I want to... | Read | |---|---| | Understand what Rosetta is and how to think about it | OVERVIEW.md | | Set up Rosetta | QUICKSTART.md | | Learn how to use Rosetta flows | USAGE_GUIDE.md | | Deploy Rosetta for my organization | DEPLOYMENT_GUIDE.md | | Understand the system architecture | ARCHITECTURE.md | | Navigate the codebase | DEVELOPER_GUIDE.md | | Contribute a change | CONTRIBUTING.md | | Debug a problem | TROUBLESHOOTING.md | | See release history | CHANGELOG.md | | Security Policy | SECURITY.md |
AI coding agents can read code, generate code, and run commands. That is where it ends. They are missing nearly everything that makes a professional software engineer reliable. Each point below addresses a real, repeatedly observed failure mode — not a theoretical concern.
Why these problems exist. LLMs generate tokens sequentially based on probabilistic weights over their current context. If the model misses a point where it should consider a specific concern — security, existing conventions, an assumption it made three steps ago — it does not return to it. It gets carried away. It performs shallow reasoning on anything it treats as a side quest, leading to catastrophic decisions. This is not a temporary limitation of current models. It is how autoregressive token generation works. Coding agent system prompts do not contain engineering process guidance — their job is to make the AI call the right tools in the right format. They cannot contain project-specific guardrails, workflows, or quality standards because the system prompt has no idea what you are building: a PoC, a pet project, a study exercise, or enterprise software with regulated data. That guidance simply does not exist in the agent unless something provides it. Rosetta provides it — and more importantly, it guides the agent on how to acquire project-specific context, when to load it, and what to do with it. The right information, at the right time, loaded into context so the model acts on it instead of skipping it.
Why this list is long. Ask any AI coding agent to design a complete workflow for implementing a feature. It will produce two or three steps — "write code" and "run tests," maybe "create a plan." It will not think about loading project context first, classifying the request, assessing risk, creating specs separately from plans, getting approval before implementation, reviewing with fresh eyes, validating against specs, handling sensitive data, updating documentation, or recording lessons learned. It will forget about all of it. Every point below is something AI agents consistently skip.
Deep project context instead of blind guessing. Without structured context, coding agents read a few line ranges around the problem and guess the rest. They do not know the architecture, the business rules, the conventions, or the dependencies. They assume. The result is code that appears correct on the surface but violates constraints the agent never knew existed. Imagine hiring a developer from outside your organization, handing them ten lines of code with zero documentation, and asking them to fix the system properly. That is how every coding agent works by default. Planning mode partially addresses this — at much higher token cost — and the agent still has to guess the purpose and target because it has no business context.
Rosetta instructions reverse this. During repository initialization, the agent — guided by Rosetta — reverse-engineers the project's architecture, tech stack, business context, coding patterns, and dependencies into structured workspace files. The agent reads these before every task. Context loads progressively — bootstrap rules first, then project context, then only the skills and workflow the current task needs. When a query returns more than five documents, Rosetta MCP switches to a listing so the agent picks exactly what it needs. Context stays lean. Reasoning stays sharp. Token efficiency is high because the agent is not loading irrelevant material or re-discovering the project from scratch on every request.
Guardrails and enforced safe behavior. Coding agents do not question their own actions. They do not question their understanding. They do not think about whether something is right or wrong. They just do it. They do not assess what they have access to — databases, cloud services, S3 buckets. They do not handle sensitive data with care. They actively copy personal data, credentials, and regulated information into logs, messages, and outputs. They do not evaluate whether an action is dangerous or irreversible.
Rosetta instructions require the agent to: critically review every user request before execution, assess risk of the current environment and available tools, detect and block dangerous and potentially dangerous actions, mask sensitive data and never log or share it, follow transparency rules and behavior boundaries, respect orchestration contracts between agents, and handle deviations when execution diverges from intent. These guardrails load at bootstrap and cannot be turned off. They are not suggestions — the agent follows them as enforced constraints.
Human-in-the-loop at decision points, not after the damage. AI coding agents fully and unconditionally trust user input — even when it is factually incorrect. At the same time, they almost never ask deep questions. When they do ask, the questions are shallow and few. This is the reverse of how collaboration should work. Users are biased, forget to mention critical requirements, provide information without much thought, and rely on common project knowledge that the agent does not have. Once implementation starts, the agent never stops — even when real conflicts or blockers exist in the code. It gets carried away, burns tokens, hallucinates to fill gaps, and delivers the wrong result. There are no checkpoints. There is no pause to verify understanding.
Rosetta workflows define approval gates at critical decision points: after specs, after plans, before risky actions, before test work continues. The agent batches questions (5–10 per round), prioritizes by impact, and targets a single decision per question. When something is unclear, the agent — instructed by Rosetta — stops and asks instead of guessing. It is almost always cheaper to stop and ask one question than to redo hours of wrong implementation.
Source of truth and request classification. AI does not establish or maintain a source of truth. It does the opposite — it mixes everything together, confuses its own outputs with ground truth, leaks abstractions, and blends responsibilities. It does not take time to think about system