NEUBRUTALISM LANDING OPEN SOURCE SKILL PACK
  • CLAUDE CODE
  • GEMINI CLI
  • CURSOR
  • CODEX

Engineering Discipline for
AI Coding Agents

Vague requests should not go straight into implementation. This pack forces clarification first, planning second, execution third, and independent review last.

Clarification → Planning → Execution → Review becomes a single operating system for AI coding: less guesswork, more structure, and much stronger verification.

View Workflow ↓ Install Now GitHub ↗
01 Clarify First

Ambiguous requests get narrowed before any coding begins.

02 Plan Before Code

Short tasks become explicit plans instead of impulse edits.

03 Independent Review

Implementation intent and verification context stay separated.

04 Long-Run Ready

Large work gets decomposed into milestones and checkpoints.

01 — WORKFLOW

A stricter route from prompt to proof

This is not just a list of skills. It is a routing system that interprets the request, chooses the right execution path, and ends with independent verification instead of “looks good to me.”

Core principle: every handoff is designed for information isolation and verifiability. Builders build. Reviewers review.

STEP 1

Clarification

Turn vague requests into bounded work using iterative questions and codebase exploration.

  • Requirement narrowing
  • Scope control
  • Complexity scoring

STEP 2A

Plan Crafting

Short tasks become executable implementation plans rather than improvised edits.

  • Concrete code-oriented steps
  • No placeholders
  • Clear sequencing

STEP 2B

Milestone Planning

Large work gets drafted from parallel exploration, then hardened by adversarial critique rounds into a milestone DAG.

  • Hidden complexity and dependencies
  • Verifiability (binary criteria)
  • Integration risk attacks

STEP 3

Run Plan / Long Run

Short tasks use worker-validator execution. Long tasks use checkpointed orchestration.

  • Retry loops
  • Checkpoint recovery
  • Parallel worktrees

STEP 4

Review Work

Review is done from the plan and the resulting code, not from implementation rationale.

  • Information isolation
  • Plan-vs-result inspection
  • Binary PASS/FAIL output

02 — SKILL MAP

Skills designed to connect, not just coexist

Each skill can be called directly, but the real value appears when they operate as a chained system: entry point, planning, execution, review, long-run orchestration, and quality reinforcement.

WORKFLOW SKILLS

The core chain

Clarification Narrow vague requests into explicit scope Plan Crafting Create executable multi-step plans Run Plan Worker-validator execution loop Review Work Isolated implementation review

LONG RUNNING

For complex work

Milestone Planning Explore → draft → adversarial critique rounds lock milestones Long Run Checkpointed orchestration for multi-day execution

INDEPENDENT SKILLS

Call on demand

Karpathy Scope discipline and surgical-change guardrails Clean AI Slop Deslop AI-generated code Simplify Reuse, quality, and efficiency review Systematic Debugging Reproduce first, fix root cause second Rob Pike's 5 Rules Measurement-driven optimization

03 — INSTALL

Attach it to the agent you already use

Claude Code, Gemini CLI, Cursor, and Codex are all supported. After installation, you can trigger the system naturally with prompts like “plan this”, “debug this test”, or “start a long run.”

Claude Code

/plugin marketplace add tmdgusya/engineering-discipline
/plugin install engineering-discipline

Gemini CLI

gemini extensions install https://github.com/tmdgusya/engineering-discipline

Cursor

/add-plugin engineering-discipline

Codex

npx skills add tmdgusya/engineering-discipline
Open-source repo: docs, HTML skill pages, and install flows all live in tmdgusya/engineering-discipline.