engineering-discipline

Engineering Discipline

한국어 | 中文

Engineering discipline skills for AI coding agents. Works with Claude Code, Gemini CLI, OpenCode, Codex, and Cursor.

How It Works

Skills chain together to handle tasks from vague request to verified implementation:

User request
    |
clarification ─── resolve ambiguity, explore codebase
    |
    |── Complexity Assessment (auto-routing)
    |       |
    |       |── Simple (score 5-8)
    |       |       |
    |       |       plan-crafting ─── create executable plan
    |       |           |
    |       |       run-plan ─── worker-validator execution loop
    |       |           |
    |       |       review-work ─── information-isolated verification
    |       |
    |       |── Complex (score 9-15)
    |               |
    |           milestone-planning ─── 5 parallel reviewers + synthesis
    |               |
    |           long-run ─── multi-day orchestrator
    |               |── M1: plan-crafting → run-plan → review-work → checkpoint
    |               |── M2: plan-crafting → run-plan → review-work → checkpoint
    |               |── ...
    |
    |── karpathy ─── implementation guardrails (before/during coding)
    |── clean-ai-slop ─── post-generation AI code cleanup
    |── simplify ─── post-implementation code quality pass
    |── systematic-debugging ─── reproduce-first bug fixing
    |── rob-pike ─── measurement-driven optimization

You don't need to memorize this. Each skill activates automatically based on trigger phrases and context.

Skills

Workflow Skills (chain together)

Clarification

Resolves vague requests into well-defined work scopes through iterative Q&A + parallel codebase exploration. Outputs a Context Brief with automatic complexity routing.

Triggers on: "I want to...", "I need...", "let's build...", or any request where scope isn't immediately clear.

Plan Crafting

Creates executable multi-step implementation plans from a clear scope. Every step contains actual code — no placeholders allowed.

Triggers on: "plan this", "create a plan", or after clarification completes with a Simple verdict.

Run Plan

Executes plans using worker-validator pairs. Workers implement, validators verify independently with zero knowledge of the worker's approach.

Triggers on: "run the plan", "execute the plan", or after plan-crafting completes.

Review Work

Information-isolated post-execution verification. Reads only the plan document and the codebase — receives no execution logs or worker output.

Triggers on: "review the work", "verify the implementation", or after run-plan completes.

Simplify

Reviews changed code through three parallel agents (reuse, quality, efficiency), then fixes any issues found.

Triggers on: "simplify", "clean up the code", "review the changes".

Long Running Execution

For complex tasks that span multiple days.

Milestone Planning (Ultraplan)

Spawns 5 independent reviewer agents in parallel — feasibility, architecture, risk, dependency, user value — then synthesizes their findings into an optimized milestone dependency DAG.

Triggers on: "plan milestones", "break this into milestones", "ultraplan", or after clarification with a Complex verdict (score 9-15).

Key features:

• 5 parallel reviewers with information isolation (no cross-pollination)
• Synthesis agent with conflict resolution log
• Independent DAG validation after synthesis
• Milestone count guard (warn >7, require approval >10)

Long Run Harness

Orchestrates multi-day execution. Each milestone passes through plan-crafting, run-plan, review-work with checkpoint/recovery.

Triggers on: "long run", "start long run", "execute milestones".

Key features:

• State persisted to disk after every phase transition (survives crashes)
• Retry escalation: re-execute → re-plan → stop (with persistent counter)
• Parallel milestones via worktree isolation
• Recovery protocol for interrupted sessions
• Rate limit handling aligned with Claude Code's built-in retry
• Context window management for long conversations
• Mid-execution correction and milestone addition procedures

Standalone Skills

Karpathy Guidelines

Preventive guardrails for code implementation — enforces surgical changes, assumption verification, and scope discipline before and during coding.

Triggers on: Before implementing features, modifying code, or when generating code without reading existing context first.

Clean AI Slop

Corrective cleanup of AI-generated code. Removes LLM-specific patterns (over-commenting, unnecessary abstractions, defensive paranoia, verbose naming, filler) while preserving behavior. Regression-tests-first, single-smell-pass discipline.

Triggers on: "clean up", "deslop", "slop", "clean AI code", or after any significant generation session.

Rob Pike's 5 Rules