Delegate Coding, Keep Judgment: Olddonkey Skills

Where this fits

You're building an agent that needs to ship code fast, but you don't trust a fast model to make architectural decisions alone. You want to use Codex, grok, or cursor-agent for the heavy lifting—writing functions, fixing boilerplate, generating tests—while keeping Claude as the reviewer who actually signs off on the diff. Olddonkey Skills gives you a structured loop for exactly that: delegate implementation, keep judgment.

Why agents benefit

• Separation of execution and judgment: Claude reviews the real diff, runs the full test gate, and only ships what it would own. The implementer backend (Codex, grok, cursor-agent) is a dial you can switch without changing the review discipline.
• Plan-first engineering mode: codex-engineering-mode forces a goal-first approach—investigate, design, plan—before any code is written, reducing blind implementation.
• Unit-by-unit driving: The loop works in small increments, so Claude can catch issues early and course-correct before they compound.
• Cursor plugin integration: The cursor-implementation-loop brings the same discipline into Cursor, letting you use your existing editor workflow.
• Reusable and composable: Skills are distilled from real workflows that broke and got fixed, so they encode practical guardrails, not just theoretical best practices.

Practical scenarios

Delegating a feature to Codex without losing control

You need to add a new API endpoint. Instead of letting Codex run wild, you invoke the implementation loop: Claude defines the task, Codex writes the code, Claude reviews the diff, runs tests, and either approves or sends it back. The result: speed from Codex, safety from Claude.

Refactoring a legacy module with engineering mode

You have a tangled module that needs restructuring. codex-engineering-mode first has Claude investigate and design a plan, then drives the implementation loop unit by unit. Each refactor step is verified before moving on, preventing a cascade of broken dependencies.

Using the Cursor plugin for a plan-first workflow

You're already in Cursor and want the same loop without switching tools. The plugin adds the plan-first loop and engineering mode as commands, so you can delegate to cursor-agent while Claude (or your configured reviewer) still gates the merge.

Add it to your agent workflow

Install with:

npx skills add olddonkey/olddonkey-skills

Then invoke the loop in Claude Code. For example:

Use the codex-implementation-loop skill. Task: implement a retry wrapper for the HTTP client. Use Codex as the backend. Run the existing test suite after implementation and report failures.

Claude will orchestrate the delegation, review the diff, run tests, and only present a final, shippable result.

Compare before adopting

Before you commit, compare against alternatives like writing your own delegation prompts or using a single-agent approach. Look at quality signals: does the skill actually enforce a review gate, or just pass through code? Check maintenance freshness—are the skills updated as models and APIs change? And consider workflow fit: does the loop match your team's existing review and testing habits?

Why it is worth tracking

Olddonkey Skills is young (15 stars) but practical—it solves a real pain point of delegating without losing quality. The author's focus on real-world breakage and fixes suggests the skills will evolve with actual usage. Watch for more backends, improved review heuristics, and community feedback. If you're building agents that need to scale implementation without sacrificing judgment, this is worth evaluating now. See the full skill details on OpenAgentSkill for the latest status.