Engineering governance and context for AI coding agents — shared instructions, architecture, standards, workflows, and guardrails in every session.

What is Rosetta

Rosetta-guided work follows five phases: Prepare (load guardrails and context), Research (gather relevant knowledge), Plan (produce a reviewable plan), Act (execute with full context), and Validate (verify with real execution evidence). Read more in the Usage Guide.

Skills

Reusable units of work the AI loads on demand. Workflows pick them for you, and most can also be called by name.

Let Rosetta decide

1. rosetta: You want Rosetta to handle it itself. Classifies your request, picks the matching workflow, and runs it end to end.

Understand what exists

1. load-project-context: Gives the AI your project’s business context, architecture, and past decisions before any work starts.
2. codemap: Gives the AI a structural map of the repo to navigate by. Uses your LSP or code-graph tooling when available.
3. discovery: Evidence-backed picture of what exists today, including whether this was already attempted and done wrong.
4. reverse-engineering: Recovers domain rules and intent from code into business specs.
5. research: Researches any question grounded in your project, with real sources. Compares options and validates its own conclusions.

Decide what to build

1. requirements-authoring: Precise and atomic requirement units: EARS acceptance criteria, rationale, alternatives, dependencies, traceability. You combine them into stories or features.
2. requirements-use: Plans and builds from approved requirements. Every task, test, and result traces back to a requirement ID.
3. design: Deep architecture decisions with defended rejections, plus domain playbooks: distributed systems, multi-tenancy, payments, regulated data, migrations.
4. tech-specs: Produces target-state interfaces, API contracts, data models, and security considerations. Forces the AI to read the real code, grounding its assumptions.
5. planning: An ordered graph of AI sessions for automated execution, each with its own scope, checklist, and handoff.
6. backlog: Turns a thin ticket into a buildable one: gaps found, questions posed, facts written back. Also produces a WBS for people.
7. reasoning: Breaks a hard problem down, identifies roles, boundaries, events, models. Works via Tree-of-Thoughts, expanding every alternative to its conclusion before committing.

Build it

1. coding: Simple, minimal, in-scope changes following KISS/SOLID/DRY. Systematic dependency-ordered validation: database, API, web, mobile. Covers IaC.
2. testing: Isolated and idempotent at 80%+ coverage, external calls mocked only. Scenario tests start from a sequence diagram: what depends on what, what is shared setup, then the test.
3. debugging: OODA. Root cause with evidence before any fix, one hypothesis at a time, prevention recommended. Three failed fixes means a design problem.
4. security: Threat modeling plus code, dependency, IaC, container, cloud, and API review. Secrets gated before ingestion, active testing only where authorized. Output is remediation tasks.
5. natural-writing: Strips AI giveaways: hype words, em-dashes, rhetorical questions, fake engagement. For docs, emails, posts, release notes.

Test automation and QA

1. qa-knowledge: QA engineering end to end: sources into requirements, gap analysis, Given-When-Then specs, TMS export, runnable API and UI tests, failure triage. Every case is implemented or recorded as a gap, never dropped.
2. qa-structure: Canonical paths, slugs, and state files for QA runs. Each session in its own folder, so parallel runs never collide and a long flow knows which phase is done.
3. data-collection: Read-only pull from issue tracker, test management, wiki, and the codebase. A ticket gets recorded, not acted on. Gaps and permission walls recorded, never guessed.

Delegate the work

1. orchestration: Sizes the work, builds and briefs a subagent team, and gates every result through fresh eyes instead of self-review. Large plans run with phases, steps, and tasks.
2. subagent-directives: Requested automatically by the orchestrator for every subagent: stay in scope, stop and report when blocked rather than improvise, prove each claim with links and line ranges.
3. large-workspace-handling: Use when a repository is too big to handle at once. Splits into non-overlapping scopes, one subagent each, then a second wave verifies the work.
4. coding-agents-farm: Runs Claude, Codex, Copilot, Gemini and others in parallel on isolated git worktrees, for throughput or cross-model validation. Burns money fast, so it is gated behind explicit consent.

Keep the session on track

1. hitl: Makes the AI work together with you. Approval gates at specs, implementation, and closing, with review in small batches. A clear affirmative counts.
2. questioning: A few high-impact questions before work starts, each one decision, with why it matters and a recommended answer. Anything researchable it answers itself.
3. self-organization: Keeps work organized as it grows: splits oversized tasks and files, clears stale content, flags when a session should restart. Announces before it reorganizes.

Stay safe

1. sensitive-data: Secrets, keys, PII, PHI, and payment data never get read, printed, logged, or committed. Masked on sight, and the same care applies to the code it writes.
2. dangerous-actions: Before anything irreversible: blast radius first, safer alternatives offered, explicit approval required. Higher environments are off limits.
3. risk-assessment: Checks what the AI can actually reach, such as databases, cloud accounts, and production servers. Rates the risk and blocks outright when it is critical.

Recover when it goes wrong

1. deviation: Stops the moment work no longer matches what you asked, or the AI cannot stand behind its own solution. Escalates instead of pressing on.
2. self-learning: After a failure or a wrong result, stops and finds the cause, then records a reusable rule in the repo’s memory so it does not repeat.
3. post-mortem: Diagnoses why a session went wrong across your prompt, workspace docs, local config, Rosetta instructions, and tooling. Can file a sanitized issue when Rosetta is at fault.

Extend

1. harness: Builds what the AI needs to run and check your system: command-line and MCP actions, dev containers, skills, subagents, workflows, hooks, and unattended automation. Encoded once, proved on every run.
2. coding-agents-prompt-authoring: Write, review, harden, and port your own skills, subagents, workflows, and rules, including between different IDEs and agents.
3. coding-agents-hooks-authoring: Author, register, and debug hooks that fire on agent actions across every supported IDE.

Domain packs

1. solr-query: Apache Solr queries that return what you meant: eDisMax, block join, JSON facets, kNN, explain output, relevancy tuning.
2. solr-schema: Apache Solr schema and solrconfig, audit or design: field types, analyzer symmetry, docValues, synonyms, commit strategy.
3. solr-extending: Custom Apache Solr plugins: SearchComponent, DocTransformer, QParser, update processors, function queries, and their solrconfig wiring.
4. solr-semantic-search: Phrase-tagging semantic search on Solr: concept tagging, taxonomy, graph paths, ambiguity resolution. Lexical, not vector.
5. specflow-use: Connects your workspace to Grid Dynamics SpecFlow through its MCP.

Top Workflows

1. coding-flow: AI creates features, fixes defects, and performs refactoring, everything end-to-end. AI performs discovery, design, specs and a plan, user review, then AI implements and runs separate review and validation passes (including running application). Most useful for medium to large coding tasks, and for controlled component-by-component migration/modernization work.
2. requirements-authoring-flow: AI works with user and raw artifacts to define entire-application requirements. AI discovers context and existing constraints, captures intent, drafts atomic requirement units, validates them, and finalizes traceability artifacts. This is the most efficient use of coding agents. Requirements then Coding.
3. security-flow: AI runs an authorized, evidence-preserving security review through mandatory specialist subagents. It gates secret-bearing files before source ingestion, bounds active testing to approved pre-production targets, independently reviews evidence, and prepares concise inputs for a later coding flow without starting remediation.
4. testgen-flow, api-aqa-flow, ui-aqa-flow: AI handles QA-related work such as generating test cases and creating API or UI automation tests. AI first collects project context, requirements, and existing QA assets, clarifies gaps, and only after that generates test cases or automation tests.
5. code-analysis-flow: AI creates grounded analysis documents based on the codebase. AI first loads project context, asks clarification questions, then produces either one focused analysis document or parallel module analyses plus a summary.
6. help-flow: AI explains available Rosetta workflows, skills, and agents. Most useful when the user is unsure which Rosetta capability to use.
7. init-workspace-flow: AI sets up a repository for AI use in both brownfield and greenfield projects. AI first analyzes the workspace, builds baseline docs, asks gap-filling questions, and verifies the result. Use it once per repository as its purpose is to build context for subsequent sessions.

If you prefer to follow your own workflows, check the skills above.

Why use it

• Context engineering, not prompt hacking. Agents receive your conventions, architecture, and business rules automatically — structured, versioned, and ready before the first line of code. See how it fits your workflow.
• Write once, run everywhere. Agent-agnostic design adapts to any IDE and any tech stack. No per-tool maintenance.
• Guardrails built in. Approval gates, risk assessment, and data protection ensure consistent AI behavior across teams. See how Rosetta protects you.
• One-command onboarding. New repo, new developer — productive immediately with best practices baked in.
• Instructions as code. Prompts version-controlled with release management — single source of truth for all teams.

How it works

Your IDE loads Rosetta as a plugin — the default, with no server and no live connection needed — or connects to the Rosetta MCP server if your IDE has no plugin or you need centrally-managed instructions. Either way, Rosetta exposes guardrails and common best practices, and provides a menu of available instructions — workflows and coding conventions. The coding agent selects only what it needs for the current task; Rosetta delivers just those, keeping the agent’s context lean. By design, no source code or project data reaches Rosetta.

Rosetta is designed to not see your source code or IP. It only serves knowledge and instructions to the agent. The agent loads only what it needs per request (progressive disclosure) and follows your organization’s workflows.

Get Started

After installation, ask:

Greenfield (new repository):

Initialize this repository using the respective Rosetta workflow, this is a new repository, target tech stack: ..., target architecture: ..., business context: ...

Brownfield (existing repository):

Ask the agent to initialize the repository:

Initialize this repository using the respective Rosetta workflow

Optionally, add details to that same request. If your workspace contains multiple repositories:

Initialize this repository using the respective Rosetta workflow, this is a composite workspace

To tell the agent where dead code or existing specs live:

Initialize this repository using the respective Rosetta workflow, dead code is in <path>, existing specs are in <path>

STDIO transport is available for environments with limited internet access. All IDEs and detailed setup. Read more in the Quick Start.

Tech Demo: Init and Coding

Tech Demo: Frontend Migration

Supported IDEs and Agents

• Cursor
• Claude Code
• VS Code / GitHub Copilot
• JetBrains (Copilot, Junie)
• Windsurf
• Codex
• Antigravity
• OpenCode

Works with any other IDE too — via a plugin where supported, via MCP otherwise.

Documentation

Contributing

Contributions welcome. See Contributing for workflow and expectations.

Community

• rosetta-support@griddynamics.com

License

See LICENSE for details.