Using Rocky: agentic-assisted programming value report

For engineers and leads using Cursor or Claude on real repos, solo or on a team.

Connecting Rocky (handbook plus devkit gateway) changes agentic-assisted work: implement a feature, add tests, pass review, open a PR. You do not need a private team server. The public handbook applies to your repo.

Full source doc: using-mcp-devkit-report.md. Product intro: I shipped Rocky.

Side-by-side

Same kind of task everywhere: implement or fix something in the user's repo, then get it review-ready.

Token ranges are directional estimates for a medium feature. Log two comparable sessions in your org if finance needs proof.

Same five phases

Measured example (same MCP workflow)

Numbers from a real session on a large client project (production React monorepo): add Vitest and Playwright for table filters, with vs without MCP connected.

Executive numbers

Tokens by phase (midpoints)

Discovery 125 vs 14 is the story: a briefing instead of walking every room.

Sonnet 4.6 cost by phase (example)

OpenRouter list rates in the source doc (May 2026): $3/M input, $15/M output on Claude Sonnet 4.6.

What it was like (from the AI agent)

MCP in ~/.cursor/mcp.json is not the same as connected and green in Cursor. Config is not connection.

Without Rocky: semantic search and grep across the repo, conventions inferred from random files, full suite on repeat, no structured ready / not_ready. You can finish. It is slower, noisier, and more expensive in tokens.

With Rocky: devkit-start-task, then the router, then 2-3 handbook reads. codebase-discovery and graphify policy. Scoped repo_test / repo_lint. test_gap_finder. pre_pr_quality_gate. Same outcome, less thrashing. Context goes to your code, not to reinventing process.

For managers

Does MCP change the app or CI? No. Does it change how the AI works? Yes: shared conventions, targeted checks, less context waste. Do you need a team deployment? No for the handbook. Connect public Rocky. Repo tools need path access to your clone.

One line: same model, about 40-50% fewer tokens on a typical feature when Rocky is connected and the model follows the router (estimate).

For engineers

1. Connect devkit in Cursor. Confirm it is green.
2. Start with devkit-start-task.
3. Read codebase-discovery once per repo. Pick one router row. Do not read every agent.
4. Use repo_test / scoped tests, not the full suite every message.
5. Run pre_pr_quality_gate before opening a PR.

Install notes: docs/INSTALL.md.

Plain English for managers (2 minutes)

Problem: Developers use AI to ship faster. Without shared tooling, each session rediscovers the repo, re-guesses standards, and re-runs huge test and lint cycles. That burns time and tokens. Review still catches style issues late.

Solution in one sentence: Rocky gives the AI a team-grade handbook and small, safe repo actions (test gaps, lint summary, pre-PR gate), even for a solo developer on a public server.

How to work day to day

1. Connect Rocky / devkit MCP.
2. devkit-start-task, then codebase-discovery, then 1 agent and 1-2 rules.
3. Edit the user repo.
4. repo_test / repo_lint.
5. pre_pr_quality_gate until verdict: "ready".

Call list_handbook only when you need a URI you do not know. Load skills when you need templates, not by default. Run graphify in the terminal. Read summary sections, not the full wiki in chat.

Token breakdown (one table)

What saves tokens: router (2-3 handbook files), gateway JSON instead of pasted terminals, scoped tests, graphify summary-first.

What does not: reading every agent after list_handbook, loading all skills, pasting graphify-out/ wholesale into chat.

Solo vs team

Related Insights

• Token and cost breakdown
• Why agents and skills are split
• Architecture profiles
• Senior workflow