codebase-implementer

Implement code bodies from scale-tagged planner handoffs within isolated git worktrees.

Updated May 9, 2026
One-click install
npx skills add https://github.com/yes506/ai-driven-items --skill codebase-implementer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: codebase-implementer
Source: https://github.com/yes506/ai-driven-items/tree/main/skills/codebase-implementer
Command: npx skills add https://github.com/yes506/ai-driven-items --skill codebase-implementer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This skill solves the gap between high-level planning and working code by autonomously generating implementation bodies while enforcing strict scope discipline and safety gates.

Core Features & Use Cases

  • Autonomous Implementation: Executes code generation across multiple phases without requiring per-step user prompts.
  • Safety-First Workflow: Integrates git worktree isolation, secrets sniffing, and a mandatory human-in-the-loop merge gate.
  • Use Case: After a codebase-planner run has defined a feature, use this skill to autonomously implement the logic, run validation tests, and generate a verification report before merging.

Quick Start

Invoke the codebase-implementer skill to begin the autonomous implementation process for the current planner-confirmed plan.

Frequently Asked Questions about codebase-implementer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code generation from a development plan while enforcing scope discipline?

Autonomous code generation from a confirmed development plan is achieved by executing implementation bodies across multiple phases without per-step prompts, enforcing strict scope discipline through bounded auto-fix validation and scale-tagged handoffs.

What is the best way to isolate code implementation changes in git before merging?

Isolating code implementation changes in git is best handled using isolated git worktrees, which separate the autonomous code generation process from the main branch until a mandatory human-in-the-loop merge gate verifies the results.

Does autonomous code implementation work across different programming languages and project scales?

Autonomous code implementation supports language-agnostic generation across micro, local, feature, and system scales, applying scale-tagged planner handoffs to match the specific scope and complexity of the required software development workflow.

Can I run validation tests automatically after generating code bodies?

Validation tests run automatically during the bounded auto-fix validation phase, executing generated code bodies to verify functionality and generate a verification report before enforcing the secure merge-gate.

What are the limitations of autonomous code generation workflows regarding human oversight?

Autonomous code generation workflows limit human oversight by requiring a mandatory merge-gate, meaning code cannot be merged until a human reviews the verification report and secrets sniffing results generated within the isolated git worktree.

Why does codebase-implementer require a planner handoff before starting the workflow?

Codebase-implementer requires a planner handoff to define the feature scope, ensuring the autonomous implementation process applies strict scope discipline and generates verified code bodies matching the defined scale and requirements.