⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

old-coder

amazingang@amazingang⭐ 759 stars· last commit 2mo ago· 3 open issues

Evidence-first development — surround the implementation with an executable spec and a gauntlet of constraints (tests, types, coverage, mutation) so line-by-line review becomes optional. Use when the user explicitly asks for high-assurance or evidence-first work ("reliable", "TDD", "prove it works", "I won't read the code"), or when the change touches high-stakes domains (money, auth, data loss, concurrency, public API). For routine changes where the user just wants normal tests, write good tests directly instead of invoking this loop.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐ 759 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Old Coder skill(老码农 skill)

中文说明 →

An old coder's strategy for the agent era: don't read the code — make it run the gauntlet.

A skill that makes coding agents prove their work. Instead of you reading every line, the agent pushes its code through a gauntlet of checks and hands you a test plan before coding and an evidence report after. You review those two documents, not the code.

It's plain markdown, so it works with any coding agent that follows instructions: Claude Code, Codex CLI, Cursor, Aider, or your own agent loop.

Installation

Install old-coder:

npx skills add https://github.com/amazingang/old-coder --skill old-coder

Or manually:

  • Claude Code — copy the skill into a skills folder, then invoke /old-coder or let it trigger on high-assurance requests:
    cp -r skills/old-coder ~/.claude/skills/
    # or copy it to <project>/.claude/skills/
    
  • Other agents — add skills/old-coder/SKILL.md to your AGENTS.md, rules file, or system prompt, and keep its references/ directory alongside it.

Optional companion: old-coder-api

This repository also includes a focused HTTP/JSON API design and review skill. Install it when you want compatibility, authorization, idempotency, pagination, rate-limit, and operability gates:

npx skills add https://github.com/amazingang/old-coder --skill old-coder-api

To install both skills:

npx skills add https://github.com/amazingang/old-coder --skill old-coder --skill old-coder-api

When both apply, old-coder owns workflow, approval, and evidence; old-coder-api owns the API contract, and its gate decisions become SPEC constraints and gauntlet checks.

The idea

From Uncle Bob (Robert C. Martin), on working with coding agents (original tweet):

My current strategy is to not read any of the code written by my agents. That’s the only way I can take advantage of their productivity. What I do instead is to surround the agents with extreme constraints. Unit tests, gherkin tests, QA procedures, quality metrics, mutation testing, test coverage, and a plethora of others. In the end, I have very high confidence in the code they produce because they’ve had to run the gauntlet of all of my constraints and tests.

If you're not going to read the code, the things you do read have to carry the trust instead.

How it works

flowchart LR
    SPEC["📋 SPEC<br/>agent writes a test plan,<br/>you approve it"]
    RED["🔴 RED<br/>write a test,<br/>watch it fail"]
    GREEN["🟢 GREEN<br/>write code until<br/>it passes"]
    REF["🧹 REFACTOR<br/>clean up,<br/>tests untouched"]
    G["🛡️ GAUNTLET<br/>run every check"]
    EV["📊 EVIDENCE<br/>you read the report,<br/>not the code"]
    SPEC --> RED --> GREEN --> REF --> G --> EV
    REF -. next behavior .-> RED

You read two documents:

  • SPEC (before any code) — concrete examples of what the code must and must not do, plus which tools the agent wants to install. Approving it is the single yes/no you give.
  • EVIDENCE (after the code) — real numbers from one final fresh run, rerunnable yourself with a single command.

The gauntlet in between:

CheckThe question it answers
Full test suiteDid anything break?
Types + lint + complexityAny obvious mistakes? Any unreadable tangles?
Changed-line coverageIs every new line actually exercised by a test?
Mutation testingPlant bugs on purpose — do the tests catch them?
Property-based testsDo the rules survive hundreds of random inputs?
Real executionDoes it actually run, outside the test harness?
Supply chain & secretsDid the agent quietly pull in risky packages, or leak a key?
Suite healthAre the tests themselves stable, in any order?

Plus a menu of domain-specific layers — concurrency, UI checks, API compatibility, performance, observability — picked per task from a risk model (see references/gauntlet.md).

Effort scales with risk: a typo fix runs a couple of checks; anything touching money, logins, data, or concurrency runs everything — plus the agent attacks its own code with hostile inputs first.

Keeping the agent honest

The agent grades its own homework, so the rules are strict: never weaken a test to make it pass; never report a check that didn't run; anything unverified is labeled unverified, never pass; if no human approved the spec, the report must say so and claim less confidence.

And one limit stated plainly: the gauntlet turns the constraints expressed in the spec into executable evidence; it cannot prove the spec is complete or authenticate its own checkers and mappings. That's why you approve the SPEC, and why EVIDENCE reports bounded, auditable confidence rather than absolute proof.

What's in the repo

skills/old-coder/         reliable coding workflow (SKILL.md + references/)
skills/old-coder-api/     HTTP/JSON API design and review (SKILL.md + references/)
demo-rate-limiter/        a rate limiter built end-to-end under old-coder

The demo's evidence.md is the point of the exercise: 41 tests, 100% coverage (49/49 statements and 20/20 branches), and 22/22 planted bugs caught. More importantly, fresh-context verification of earlier green states still found real behavioral defects and an unsound mutation runner — evidence that a green gauntlet is not self-authenticating. The current report discloses both the fixes and the final state's verification status. Rerun the whole report:

cd demo-rate-limiter
python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt -e .
./tools/gauntlet.sh

License

MIT

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/old-coder/SKILL.md7.9 KBupstream ↗
    ---
    name: old-coder
    description: Evidence-first development — surround the implementation with an executable spec and a gauntlet of constraints (tests, types, coverage, mutation) so line-by-line review becomes optional. Use when the user explicitly asks for high-assurance or evidence-first work ("reliable", "TDD", "prove it works", "I won't read the code"), or when the change touches high-stakes domains (money, auth, data loss, concurrency, public API). For routine changes where the user just wants normal tests, write good tests directly instead of invoking this loop.
    ---
    
    # Old Coder: Reliable Coding Under Constraint and Test
    
    The human will NOT read your implementation. Their confidence comes entirely from
    two artifacts you produce: (1) an **executable specification** they approve before
    you write code, and (2) an **evidence report** proving the code ran the gauntlet.
    Your job is to make those two artifacts trustworthy enough that line-by-line
    review becomes optional within the spec's boundaries.
    
    This inverts the normal review model: **trust moves from inspection to
    constraints.** Be honest about what that buys: the gauntlet turns the
    constraints the spec expresses into executable evidence — it cannot show the
    spec expresses everything that matters, and it is not self-authenticating,
    because a checker can be unsound and a mapping can claim more than it
    demonstrates. That is exactly why the human approves the
    SPEC (the one artifact that breaks the everything-authored-by-the-same-agent
    correlation), and why EVIDENCE reports layered, auditable confidence, never
    absolute proof. Every shortcut you take against the gauntlet destroys the only
    basis of trust.
    
    **Composition with `old-coder-api`:** when both skills apply, this skill owns
    workflow order, SPEC approval, the gauntlet, and EVIDENCE; `old-coder-api` owns
    the HTTP/JSON contract. Run its scope check and API gates while drafting SPEC,
    turn the surviving constraints and risks into acceptance criteria and checks,
    then map those checks into EVIDENCE. Do not run two parallel workflows.
    
    ## The Loop
    
    ```
    SPEC → (human approves spec, not code) → RED → GREEN → REFACTOR → GAUNTLET → EVIDENCE
                                              ↑_____________________|
                                                  repeat per behavior
    ```
    
    ### 1. SPEC — the only thing the human reads before code
    
    Turn the request into **executable acceptance criteria** before touching
    implementation files:
    
    - Write behaviors as Gherkin-style scenarios or a named test list — concrete
      inputs, concrete expected outputs, edge cases, and error cases. "Handles bad
      input" is not a spec; `divide(1, 0) raises ZeroDivisionError with message X` is.
    - Include what the change must NOT do (invariants that must survive: existing
      tests, public API signatures, performance budgets if stated). These negative
      constraints are contract clauses like any scenario: each must end up mapped
      in EVIDENCE to a test, a gauntlet layer, or an explicit skipped-with-reason
      line — never silently absent from the mapping.
    - The spec doubles as the authorization point: include the **setup plan** —
      tools to install, git usage (init? checkpoint commit cadence?), files the
      gauntlet will add **by path**, and **every new dependency with a one-line
      justification** (prefer the standard library and deps already present; an
      unjustified package is a spec defect) — so approving the spec authorizes the
      environment changes in one step instead of N interruptions, and the human can
      veto a risky package before it is ever installed.
    - Show the spec to the human in plain language and get approval **before writing
      implementation**. In autonomous mode, state the spec in your response and
      proceed — but the correlation-breaking review never happened, so EVIDENCE
      must record `spec approval: not obtained (autonomous run)` and claim
      correspondingly lower confidence; the spec becomes the artifact the human
      reviews after the fact.
    - **An answer to a question is not an approval.** If you asked the human to
      decide something, they answered that question and nothing else. Their answer
      is an INPUT to the spec, and it CHANGES the spec — so any approval you held
      before the question is approval of a document that no longer exists. Questions
      and approval are two exchanges, in that order: fold the answers in, say what
      changed, show the revised spec, ask again. If you cannot quote the words that
      approved THIS spec, you do not have approval — an answer to your question, a
      "go ahead" about some other step, silence, and the request that started the
      task are none of them approval. The recommended-option shape makes this easy
      to get wrong: when the human picks the options you recommended, the spec looks
      unchanged and consent looks implied, and neither is true.
    - The spec is append-only during the task. If implementation reveals the spec was
      wrong, say so explicitly and revise it visibly — never silently drift.
    - **Write the spec to a file and name it by absolute path.** A relative path is
      not clickable in a terminal, so the human cannot open the one artifact they
      are being asked to approve. Same for EVIDENCE when you get there. The SPEC
      and Gherkin templates are in `references/templates.md`.
    - **Commit the spec at approval** where the repo's git conventions allow it —
      the setup plan is where that was authorized. Once the approved spec is a
      commit, later drift is literally a `git diff`. Without a durable spec, a
      compaction loses the approved contract while the code it authorized remains,
      and nobody can check whether a scenario was quietly dropped from the EVIDENCE
      mapping.
    
    ### 2. RED — prove each test can fail
    
    Write the test for one behavior. **Run it and watch it fail** before writing the
    implementation. A test you never saw fail proves nothing — it may be testing
    nothing. Details that matter in practice:
    
    - If the module under test doesn't exist yet, create a stub that raises
      (e.g. `NotImplementedError`) so the test fails on behavior, not on import —
      a collection error is a weaker RED than an assertion failure.
    - Related behaviors may share one RED run, as long as each new test is
      individually observed failing.
    - If a new test passes immediately, it is either vacuous (fix it) or the
      behavior already exists. **Don't just assert which — prove it**: break the
      implementation with a one-off throwaway mutant, watch the test fail, restore.
      Then record it as pre-existing behavior kept as regression armor.
    
    ### 3. GREEN — minimal implementation
    
    Write the least code that makes the failing test pass. Run the full suite, not
    just the new test.
    
    ### 4. REFACTOR — clean up under green, assertions frozen
    
    Minimal code is often ugly code. While the suite is green, improve names,
    extract duplication, and simplify structure. What is frozen is **behavioral
    assertions**, not test files wholesale:
    
    - Implementation refactors touch no test files at all.
    - Test-structure refactors (extracting helpers and fixtures, deduplicating
      setup) are allowed as a **separate step**: assertions unchanged, suite green
      before and after, then rerun mutation to confirm the restructured tests
      still kill — a refactor that blunts the tests is a silent hole in the
      gauntlet.
    - Anything that requires editing an assertion isn't refactoring, it's a
      behavior change and belongs back in SPEC.
    
    Run the suite after each refactor. Repeat RED→GREEN→REFACTOR per behavior.
    
    ### 5. GAUNTLET — the constraint stack
    
    After all spec behaviors are green, run every applicable layer. Scale to the task
    (see "Calibration"), but never skip a layer silently — if a layer doesn't apply
    or a tool is unavailable, record that in the evidence report with the reason.
    
    | Layer | What it catches | How |
    |---|---|---|
    | Full test suite | regressions | project's test command, zero NEW failures (baseline note below) |
    | Static types | whole classes of bugs | tsc / mypy / etc., zero new errors |
    | L
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/amazingang-old-coder-skills-old-coder.md

// REPO STATS

759 stars
3 open issues
Last commit: 2mo ago