Skip to content
Back to search

old-coder

An old coder's strategy for the agent era: don't read the code — make it run the gauntlet. Evidence-first development skill for coding agents, inspired by Uncle Bob.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/amazingang--old-coder/badge.svg)](/listings/amazingang--old-coder)

HTML

<a href="/listings/amazingang--old-coder"><img src="/api/listings/amazingang--old-coder/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 116 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/old-coder-github-banner.png" alt="old-coder: SPEC → GAUNTLET → EVIDENCE">
  3. </p>
  4. # Old Coder skill(老码农 skill)
  5. *[中文说明 →](README-zh.md)*
  6. **An old coder's strategy for the agent era: don't read the code — make it run the gauntlet.**
  7. 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.
  8. 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.
  9. ## Installation
  10. Install `old-coder`:
  11. ```sh
  12. npx skills add https://github.com/amazingang/old-coder --skill old-coder
  13. ```
  14. Or manually:
  15. - **Claude Code** — copy the skill into a skills folder, then invoke `/old-coder` or let it trigger on high-assurance requests:
  16. ```sh
  17. cp -r skills/old-coder ~/.claude/skills/
  18. # or copy it to <project>/.claude/skills/
  19. ```
  20. - **Other agents** — add `skills/old-coder/SKILL.md` to your `AGENTS.md`, rules file, or system prompt, and keep its `references/` directory alongside it.
  21. ### Optional companion: `old-coder-api`
  22. 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:
  23. ```sh
  24. npx skills add https://github.com/amazingang/old-coder --skill old-coder-api
  25. ```
  26. To install both skills:
  27. ```sh
  28. npx skills add https://github.com/amazingang/old-coder --skill old-coder --skill old-coder-api
  29. ```
  30. 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.
  31. ## The idea
  32. From Uncle Bob (Robert C. Martin), on working with coding agents ([original tweet](https://x.com/unclebobmartin/status/2080257779395154409)):
  33. > 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.
  34. If you're not going to read the code, the things you *do* read have to carry the trust instead.
  35. ## How it works
  36. ```mermaid
  37. flowchart LR
  38. SPEC["📋 SPEC<br/>agent writes a test plan,<br/>you approve it"]
  39. RED["🔴 RED<br/>write a test,<br/>watch it fail"]
  40. GREEN["🟢 GREEN<br/>write code until<br/>it passes"]
  41. REF["🧹 REFACTOR<br/>clean up,<br/>tests untouched"]
  42. G["🛡️ GAUNTLET<br/>run every check"]
  43. EV["📊 EVIDENCE<br/>you read the report,<br/>not the code"]
  44. SPEC --> RED --> GREEN --> REF --> G --> EV
  45. REF -. next behavior .-> RED
  46. ```
  47. You read two documents:
  48. - **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.
  49. - **EVIDENCE** (after the code) — real numbers from one final fresh run, rerunnable yourself with a single command.
  50. The gauntlet in between:
  51. | Check | The question it answers |
  52. |---|---|
  53. | Full test suite | Did anything break? |
  54. | Types + lint + complexity | Any obvious mistakes? Any unreadable tangles? |
  55. | Changed-line coverage | Is every new line actually exercised by a test? |
  56. | Mutation testing | Plant bugs on purpose — do the tests catch them? |
  57. | Property-based tests | Do the rules survive hundreds of random inputs? |
  58. | Real execution | Does it actually run, outside the test harness? |
  59. | Supply chain & secrets | Did the agent quietly pull in risky packages, or leak a key? |
  60. | Suite health | Are the tests themselves stable, in any order? |
  61. 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`).
  62. 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.
  63. ## Keeping the agent honest
  64. 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.
  65. 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.
  66. ## What's in the repo
  67. ```
  68. skills/old-coder/ reliable coding workflow (SKILL.md + references/)
  69. skills/old-coder-api/ HTTP/JSON API design and review (SKILL.md + references/)
  70. demo-rate-limiter/ a rate limiter built end-to-end under old-coder
  71. ```
  72. 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:
  73. ```sh
  74. cd demo-rate-limiter
  75. python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt -e .
  76. ./tools/gauntlet.sh
  77. ```
  78. ## License
  79. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.