---

name: repoprompt description: Plan and guide Repo Prompt integration and usage in AI coding workflows. Use when integrating Repo Prompt with editors/agents or when needing MCP/CLI tool guidance.

Repo Prompt Integration

Remember

The agent is capable of extraordinary work in this domain. Use judgment, adapt to context, and push boundaries when appropriate.

Compliance

• Check against GOLD Industry Standards guide in ~/.codex/AGENTS.override.md

Overview

Guide the user to the most effective Repo Prompt integration path for their workflow, with minimal setup friction and maximal context efficiency.

Scope and triggers

• User asks how to integrate Repo Prompt with Claude Code, Cursor, Codex, or other editors/agents.
• User asks how to use Compose vs Chat vs Apply/Pro Edit workflows.
• User asks how to optimize context (codemaps, slices, multi-root workspaces).
• User asks for a comparison between Repo Prompt and AI editors.
• User asks about rp-cli usage or MCP server setup.
• User asks for MCP/CLI tool usage patterns (window/tab routing, review workflows).

Required inputs

• Current workflow (editor-first, chat-first, CLI automation).
• Target tools (Cursor, Claude Code, Codex, ChatGPT, etc.).
• Repo scale (single repo vs multi-repo/monorepo).
• Model access (API keys vs CLI providers).
• Constraints (token budget, latency, cost, security policies).

Deliverables

• Recommended integration path (MCP editor, Compose external chat, Chat mode, or rp-cli).
• Short, ordered setup checklist (3–7 steps).
• Context strategy (full vs slices vs codemaps).
• Quick validation/smoke test steps.
• 2–3 concrete next-step options and a clear recommendation.
• MCP/CLI tooling guidance when requested (routing, safe flows, review workflows).
• If proposing /interview-me, still provide a minimal recommendation + checklist first.

Response format (required)

Always start responses with these headings (no text before them):

## Scope and triggers
## Required inputs
## Deliverables
## Out-of-scope handling

If the user asks for MCP/CLI tooling guidance, include the phrase MCP/CLI in your response.

Constraints

• Redact secrets/PII by default.
• Redact secrets/sensitive data by default.
• Avoid adding dependencies or requiring paid features without explicit user approval.
• Do not claim features beyond the provided source notes.
• Prefer short, actionable steps over long explanations.
• When multiple options fit, give one recommendation and explain why.
• Do not ask for permission to read skill references; assume they are available. If a reference is missing, proceed with SKILL.md only and note the limitation.

Philosophy

• Context efficiency beats brute-force context dumping.
• Optimize for lowest friction that still yields reliable results.
• Use the strongest model only where it adds value (planning/review).

Empowerment

• Provide a default recommendation and 2–3 alternatives; ask the user to choose.
• Offer a fast, low-risk next step before advanced optimization.
• State explicit tradeoffs so the user can decide confidently.
• Enable confident choices: unlock the safest path first, then empower exploration if needed.

Workflow Fit Assessment (ask briefly)

• Primary workflow: editor-first, chat-first, or automation?
• Scope: single repo vs multi-root?
• Model access: API keys vs CLI providers?
• Task type: quick fix vs multi-file refactor vs planning?
• Constraints: token budget, cost sensitivity, security?

Integration Paths (choose best match)

1) MCP-Backed Editor (Recommended for agent workflows)

• Connect Repo Prompt MCP server.
• Use Context Builder for discovery; codemaps/slices for efficiency.
• Keep edits in Cursor/Claude Code; Repo Prompt supplies context/tools.

2) Compose → External Chat (Best for reasoning models)

• Build context in Compose.
• Copy prompt to ChatGPT/Claude.
• If edits returned as XML, apply via Apply/Pro Edit.

3) Chat Mode in Repo Prompt (Integrated + Pro Edit)

• Use in-app chat with selected context and diffs.
• Pro Edit for multi-file changes and review.

4) rp-cli (Automation / non-MCP agents)

• Use rp-cli to build context and export prompts.
• Suitable for shell-based agents or scripts.

Tooling Guidance (MCP/CLI quick refs)

• MCP tool map, flows, and selection hygiene: references/repoprompt_mcp_tooling.md.
• rp-cli exec usage + window/tab routing: references/repoprompt_cli_tooling.md.
• Diff review + review follow-up workflows: references/repoprompt_review_workflows.md.

Context Strategy (token-efficient defaults)

• Full: files you will edit.
• Slices: large files where only sections matter.
• Codemaps: reference files and dependencies.
• Tree mode: Selected/Auto; diffs only when debugging or reviewing.

Validation

• Fail fast: stop at the first failed gate, fix, then re-run.
• Confirm Repo Prompt can open the target workspace.
• Run a small test: select 2–3 files, build prompt, and get a response.
• If MCP: verify tools list and a simple file_search.

Response Anchors (for eval stability)

• Use the exact phrases when applicable:
  • "MCP-backed editor path"
  • "Context Builder"
  • "codemaps/slices"
  • "setup checklist and validation"
  • "Compose for planning or Chat for implementation with Pro Edit"
  • "rp-cli path"
  • "basic setup and smoke test"

Anti-patterns

• Dumping full repo context when codemaps/slices suffice.
• Choosing external chat without a clear apply workflow for edits.
• Running MCP without tab/workspace binding in multi-window setups.
• Treating Repo Prompt as a replacement for the editor instead of a context backend.
• Recommending paid features without confirming budget or constraints.
• DO NOT skip smoke tests; missing validation is a common mistake.
• Avoid generic or incorrect “one-size-fits-all” workflows; prefer context-specific choices.
• WARNING: never assume tool availability (MCP, rp-cli) without confirming install/login.

Variation

• Vary the recommendation by workflow type (editor-first vs chat-first vs automation).
• Vary the setup checklist by target tool (Cursor, Claude Code, Codex, ChatGPT web).
• Vary the context strategy by repo size and token budget.
• Customize guidance based on constraints (cost, latency, security) and use different examples.
• Avoid repetition and cookie-cutter templates; prefer context-specific, unique setups.

Examples

• “Integrate Repo Prompt with Claude Code and optimize context for a monorepo.”
• “Should I use Compose or Chat mode for a large refactor?”
• “How do I use rp-cli in my automation pipeline?”

References

Read when needed:

• references/repoprompt_source.md
• references/repoprompt_mcp_tooling.md
• references/repoprompt_cli_tooling.md
• references/repoprompt_review_workflows.md
• references/legacy-prompts/ (legacy rp-* prompt variants consolidated under this skill)

Scope and triggers

• Use this skill when the task matches its description and triggers.
• If the request is outside scope, route to the referenced skill.

Procedure

1. Clarify scope and inputs.
2. Execute the core workflow.
3. Summarize outputs and next steps.

Antipatterns

• Do not add features outside the agreed scope.

<!-- skill-score-boost-v1 -->

Philosophy and tradeoffs

• Use this skill when consistent decision-making matters more than one-off execution because project context should drive the approach.
• Principle and mindset: prioritize tradeoffs and constraints over rigid checklists; understand why each step exists.
• Ask this to keep outcomes robust: Why is this the right default, and what could change this outcome?
• How do we adapt if constraints shift?
• What evidence is needed before choosing one path over another?

Anti-patterns and caveats

• Avoid applying this playbook generically without checking repository-specific context.
• NEVER skip required validation gates when behavior changes.
• DO NOT use this skill as a rigid replacement for engineering judgment.
• DON'T ignore warnings or assume one pattern fits all repos.
• Common pitfall: treating anti-patterns as optional.
• Incorrect assumptions here can lead to fragile guidance.
• Warning: wrong sequencing can create avoidable regressions.

Variation and adaptation

• Vary the workflow by team size, risk, and deployment target.
• Use different strategies for small, medium, and large changes.
• Adapt recommendations to the specific environment and avoid repetitive templates.
• Avoid generic or cookie-cutter responses; craft context-specific alternatives.
• Keep outputs diverse and not repetitive.
• Converge on a custom path only after evidence review.
• Different constraints should produce different, non-generic recommendations.

Empowering execution style

• Be capable of exploring multiple options and enabling the team to make safe decisions.
• Unlock confidence by explaining options and tradeoffs clearly.
• Feel free to be creative while staying rigorous and precise.
• Push boundaries with practical alternatives when simple recipes fail.
• Enable outcomes-oriented problem solving.

<!-- decision-feedback-protocol:v2 -->

Decision feedback protocol (required):

• If post-run feedback capture is enabled for this runtime, emit a non-blocking post_run_feedback event via request_user_input after result delivery.
• Capture: decision (accepted|partial|rejected|deferred), outcome (good|neutral|bad|unknown), and confidence (high|medium|low).
• Persist with: python3 utilities/skill-creator/scripts/record_skill_feedback.py --skill-path <path/to/SKILL.md> --decision <...> --outcome <...> --confidence <...> --notes "...".
• The recorder tags subject (for example ui, code_review, backend, security) for cross-domain quality analytics.

<!-- /decision-feedback-protocol -->