by griddynamics
Meta-prompting, context engineering, and centralized instructions management for AI coding agents - by Grid Dynamics
# Add to your Claude Code skills
git clone https://github.com/griddynamics/rosettaLast scanned: 6/2/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-06-02T08:39:38.982Z",
"npmAuditRan": true,
"pipAuditRan": false
}rosetta is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by griddynamics. Meta-prompting, context engineering, and centralized instructions management for AI coding agents - by Grid Dynamics. It has 319 GitHub stars.
Yes. rosetta passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/griddynamics/rosetta" and add it to your Claude Code skills directory (see the Installation section above).
rosetta is primarily written in TypeScript. It is open-source under griddynamics on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh rosetta against similar tools.
No comments yet. Be the first to share your thoughts!
https://github.com/user-attachments/assets/6df6e217-3e5c-4691-84ed-7440701a87de
AI coding agents are great — until you try to use them across a real team. Everyone builds their own prompts and instructions, knowledge stays in silos, and the agent — not knowing your architecture or constraints — guesses from a few open files and confidently does the wrong thing.
That's why we built Rosetta — open-source engineering governance and context for AI coding agents. It's not another proprietary agent; it works with the tools you already use (Claude Code, Cursor, Copilot, Codex, and other MCP-compatible agents) and loads your team's shared engineering instructions into every session. Everything is versioned in Git and can run inside your perimeter.
Teach agents how to think, not what to do. The model already knows Python and React; what it lacks is your engineering discipline. That's what Rosetta encodes.
Rosetta-guided work follows five phases — Prepare → Research → Plan → Act → Validate — with approval gates at the key decision points. Read more in the Usage Guide.
[!NOTE] If you are effectively using your current setup, writing your own skills, and managing AI using your own processes, you probably don't need Rosetta.
| Without Rosetta | With Rosetta |
|---|---|
| Each developer writes their own prompts and instructions | One versioned, shared source of truth |
| The agent guesses from a few open files | It reads your architecture and conventions first |
| Starts coding immediately | Prepare → research → plan → act → validate |
| Reviews its own work in the same context | A fresh-context reviewer subagent checks it |
| "Generate and hope" | Validation with real execution evidence |
| Knowledge stuck in senior engineers' heads | Captured once, reused everywhere |
| Without Rosetta | With Rosetta |
|---|---|
| Jumps straight into editing the handler | Reads ARCHITECTURE.md and your existing conventions first |
| Misses the shared middleware pattern; duplicates the Redis client | Reuses the shared rate-limiter and Redis layer |
| No plan, no checkpoint | Proposes a plan and asks for approval |
| Ships without running tests | Runs the integration tests, then a fresh-context reviewer validates |
1. Install — pick the option that fits:
| Option | Best for |
|---|---|
| Plugins — recommended | Day-to-day developer use (Claude Code · Cursor · Copilot · Codex) |
| Hosted MCP | Fast evaluation for Windsurf · Junie · Antigravity · OpenCode · any MCP-compatible agent |
| Self-hosted MCP | Enterprise / air-gapped deployment of the same MCP-compatible setup |
2. Initialize — ask the agent in chat once per repo, and Rosetta does the rest:
flowchart LR
D["ask to initialize<br/>in chat"] --> A["Rosetta detects mode<br/>and analyzes your repo"]
A --> W["creates workspace baseline<br/>TECHSTACK · CODEMAP · DEPENDENCIES · CONTEXT · ARCHITECTURE"]
W --> Q["asks gap-filling<br/>questions"]
Q --> S["you build with<br/>/coding-flow · /aqa-flow · …"]
classDef step fill:#1f6feb,stroke:#1b4fb8,color:#ffffff;
class D,A,W,Q,S step
Full setup and initialization steps are in the Quickstart · all IDEs and detailed setup.
Rosetta layers your instructions at runtime — core, then organization, then project, each building on the one above — and adapts the result to whatever agent you use:
flowchart LR
A["<b>Core</b><br/>best practices & workflows"] --> B["<b>Organization</b><br/>standards, policies & guardrails"]
B --> C["<b>Project</b><br/>architecture, context & constraints"]
C --> R["<b>Rosetta Runtime</b><br/>context engineering + instruction orchestration"]
R --> AD["<b>Agent Adapters</b>"]
AD --> G["<b>Guided Execution</b><br/>workflows • guardrails • validation"]
G --> T["Claude Code · Cursor · Copilot · Codex · Windsurf"]
classDef rosetta fill:#1f6feb,stroke:#1b4fb8,color:#ffffff;
classDef yours fill:#2da44e,stroke:#1a7f37,color:#ffffff;
classDef third fill:#d0d7de,stroke:#8c959f,color:#1f2328;
class A,R,AD,G rosetta
class B,C yours
class T third
Legend: 🟦 shipped with Rosetta (Core, Runtime, adapters, execution) · 🟩 authored by your org & project · ⬜ your existing AI tools (third-party).
Higher layers propagate to every project automatically; teams customize without forking. Everything is authored in markdown and versioned in Git.
IDE rules (.cursorrules, CLAUDE.md, Copilot custom instructions) are useful, but they are usually local to one tool, one repo, or one developer. Rosetta makes instructions layered, versioned, reusable, and portable across agents and IDEs — organization standards flow into every project, while project-specific context stays local and customizable. On top of that, Rosetta adds the workflows, guardrails, and approval gates that flat rules files do not provide.
| For builders | For organizations |
|---|---|
| Deep project context — reads your architecture and conventions, not a few open files | One standard across every team, tool, model, and repo |
| Plain-language tasks — a slash command, no prompt scaffolding or new syntax | No vendor lock-in — one instruction set across Claude Code, Cursor, Copilot, Codex; engineers keep their IDEs |
| Ready-made flows — coding, testing, AQA, research, and more | Versioned control — review, approve, and roll back instructions in Git |
| Plans and approval gates before code, not after the damage | Knowledge captured once — out of senior engineers' heads |
| Fresh-context review and execution-backed validation | Cross-project intelligence (opt-in) — agents see the system, not just one repo |
| Less babysitting — fewer wrong turns to catch and re-prompt | Runs inside your perimeter — air-gap capable; no source code leaves |
See how Rosetta fits your workflow and how it protects you.
AI coding agents can read code, generate code, and run commands. But that is only part of what makes software engineering reliable — they are missing much of the discipline a professional engineer brings. Each point below addresses a real, repeatedly observed failure mode, not a theoretical concern.
Why these problems exist. LLMs generate tokens sequentially from their current context. If the model passes a point where it should weigh a specific concern — security, an existing convention, an assumption it made three steps ago — it does not reliably circle back. This is not merely a temporary limitation; it is rooted in how autoregressive generation works. A coding agent's system prompt only ensures the model calls the right tools in the right format — it can't carry your project's guardrails, workflows, or