Skip to main content

Lab: Make a Repository Agent-Ready

Lab

Applies to: engineers about to point a coding agent at an unfamiliar repo · Time to learn: 90-120 minutes hands-on · Lever: context + feedback + guardrails (all three)

You will take a tiny polyglot repository (a Python service, a TypeScript client, an OpenTofu module, and an optional Go CLI) and add one lever at a time: a single verify command, fast linters, a short AGENTS.md, formatting and secret-guard hooks, a project skill, and execution plans. Then you run an agent against it and watch the levers work. Every step links to the theory page that explains the why; this page is the doing.

TL;DR
  • Start with the feedback loop: one command (mise run check) that lints and tests every language. Everything else builds on it.
  • Put the verify command in a short AGENTS.md; make CLAUDE.md a one-line @AGENTS.md import.
  • Enforce with hooks and pre-commit, advise with AGENTS.md. A hook blocks; a rule only asks.
  • Keep plans in docs/plans/<epic>/ and start each plan in a fresh session with /clear.
  • Outputs on this page were measured in a scratch directory on 2026-10-22; steps marked "not measured" were not run.

Why it matters in the AI age​

An agent is only as good as (1) the context it gets, (2) the feedback loop it can run, and (3) the guardrails around it. A repository that has none of these makes the agent guess: which Python, which test command, whether the edit it just made is valid. A repository that has all three lets the agent iterate on real tool output, which is what it does best. This lab builds each lever in the smallest form that works, so you can repeat it on a client repo in an hour. See the overview for the three-lever model.

LeverWhat you addStep
Feedbackmise.toml tasks, linters, tests1, 2
ContextAGENTS.md, skill, plans, scratchpad, docs MCP3, 6, 7, 8
Guardrailspre-commit, PostToolUse and PreToolUse hooks4, 5

Step 0: Prerequisites and starting repo​

ItemNeededMeasured with (as of 2026-10-22)
git, bash, jqyesgit 2.47.3, jq present
miseyes, installs every other tool2026.10.17
uvfor uvx prek and the MCP serverpresent
Claude Codefor steps 5, 6, 9not measured (no interactive session in the authoring sandbox)

Install mise from mise.jdx.dev, then create the starter repo. The script is self-contained and makes one commit.

scaffold.sh
#!/usr/bin/env bash
set -euo pipefail
mkdir -p shop && cd shop
git init -q -b main
mkdir -p services/api/app services/api/tests web/src infra/modules/bucket cli

cat > services/api/app/__init__.py <<'PY'
PY
cat > services/api/app/pricing.py <<'PY'
import os, sys


def total_cents(items, tax_rate=0.2):
subtotal = sum(i["price_cents"] * i["qty"] for i in items)
return round(subtotal * (1 + tax_rate))


def unused():
return os.getcwd()
PY
: > services/api/tests/__init__.py
cat > services/api/tests/test_pricing.py <<'PY'
import unittest

from app.pricing import total_cents


class PricingTest(unittest.TestCase):
def test_total_with_tax(self):
items = [{"price_cents": 1000, "qty": 2}]
self.assertEqual(total_cents(items), 2400)

def test_empty_cart(self):
self.assertEqual(total_cents([]), 0)
PY
cat > services/api/pyproject.toml <<'TOML'
[project]
name = "shop-api"
version = "0.1.0"
requires-python = ">=3.12"
TOML

cat > web/src/format.ts <<'TS'
export function formatPrice(cents: number, currency = "EUR"): string {
return new Intl.NumberFormat("en", { style: "currency", currency }).format(cents / 100);
}
TS
cat > web/src/format.test.ts <<'TS'
import assert from "node:assert/strict";
import { test } from "node:test";
import { formatPrice } from "./format.ts";

test("formats euro cents", () => {
assert.equal(formatPrice(2400), "€24.00");
});
TS
cat > web/package.json <<'JSON'
{
"name": "shop-web",
"private": true,
"type": "module"
}
JSON

cat > infra/modules/bucket/main.tf <<'HCL'
variable "name" {
type = string
description = "Bucket name"
}

locals {
tags = { project = "shop" }
}

output "tags" {
value = local.tags
}
HCL

cat > cli/go.mod <<'MOD'
module example.com/shop/cli

go 1.24
MOD
cat > cli/main.go <<'GO'
package main

import "fmt"

func Greeting(name string) string { return "hello, " + name }

func main() { fmt.Println(Greeting("shop")) }
GO
cat > cli/main_test.go <<'GO'
package main

import "testing"

func TestGreeting(t *testing.T) {
if got := Greeting("x"); got != "hello, x" {
t.Fatalf("got %q", got)
}
}
GO

cat > .gitignore <<'EOF2'
.env
node_modules/
__pycache__/
.ruff_cache/
.terraform/
.claude/settings.local.json
scratchpad/
EOF2
git add -A && git -c user.name=lab -c user.email=lab@example.com commit -qm "chore: starter repo"
echo "scaffolded $(pwd)"
mkdir -p ~/agent-ready-lab && cd ~/agent-ready-lab
bash scaffold.sh && cd shop

The starter layout (the Python file has a deliberate unused import for step 2):

shop/
services/api/ app/pricing.py, tests/test_pricing.py, pyproject.toml
web/ src/format.ts, src/format.test.ts, package.json
infra/modules/bucket/main.tf
cli/ main.go, main_test.go, go.mod (optional Go part)
Go is optional

Skip the cli/ directory and the Go lines in mise.toml if you do not use Go. The Go lines were run in this lab (Go 1.27.3 via mise), but nothing else depends on them.


Step 1: One command that verifies everything​

Theory: The Agent-Ready Toolchain. Lever: feedback.

mise pins tool versions and runs tasks from one file. The agent (and every teammate) gets the same ruff, biome, and trivy, and one command to run.

mise.toml
[tools]
python = "3.13"
node = "24"
go = "1.27"
opentofu = "1.13.2"
ruff = "0.17.2"
biome = "2.6.2"
golangci-lint = "2.15.0"
trivy = "0.76.1"
gitleaks = "8.30.1"

[tasks.lint]
description = "Static checks for every language (read-only)"
run = [
"ruff check services/api",
"ruff format --check services/api",
"biome check web",
"cd cli && golangci-lint run ./...",
"tofu fmt -check -recursive infra",
"tofu -chdir=infra/modules/bucket init -backend=false -input=false",
"tofu -chdir=infra/modules/bucket validate",
"trivy fs --scanners vuln,secret,misconfig --severity HIGH,CRITICAL --exit-code 1 --quiet .",
"gitleaks dir . --no-banner",
]

[tasks.test]
description = "Unit tests for every language"
run = [
"cd services/api && python -m unittest discover -s tests -t .",
"cd web && node --test \"src/**/*.test.ts\"",
"cd cli && go test ./...",
]

[tasks.check]
description = "The one command: lint, then test"
depends = ["lint", "test"]

Install and run:

mise trust && mise install # first run downloads all nine tools
mise run check

Measured result on the starter repo, before any linter config: the check fails, as it should.

$ mise run check
[lint] $ ruff check services/api
[lint] I001 [*] Import block is un-sorted or un-formatted
[lint] --> services/api/app/pricing.py:1:1
[lint] F401 [*] `sys` imported but unused
[lint] --> services/api/app/pricing.py:1:12
[lint] Found 2 errors.
[lint] [*] 2 fixable with `--fix`.
[lint] ERROR task failed

mise install fetched all nine tools in 15.2 s on the authoring machine (warm network, Linux x64). Versions installed:

ToolPinSource
python3.13 (3.13.17)mise python docs
node24 (24.22.1)mise configuration
go1.27 (1.27.3)go.dev/dl
opentofu1.13.2release
ruff0.17.2release
biome2.6.2release
golangci-lint2.15.0release
trivy0.76.1release
gitleaks8.30.1release

Pins are "latest on 2026-10-22". Check each release page when you start a real project. For tighter supply-chain control, see mise paranoid mode and How We Build for the Trivy incident.


Step 2: Linters and formatters​

Theory: The Agent-Ready Toolchain. Lever: feedback.

Add one config per language. Keep them small; the point is a deterministic pass or fail.

services/api/pyproject.toml (append)
[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
extend-select = ["B", "I", "UP"]
biome.json
{
"$schema": "https://biomejs.dev/schemas/2.6.2/schema.json",
"vcs": { "enabled": true, "clientKind": "git", "useIgnoreFile": true },
"files": { "includes": ["web/**"] },
"formatter": { "enabled": true, "indentStyle": "space", "lineWidth": 100 },
"linter": { "enabled": true, "rules": { "preset": "recommended" } },
"javascript": { "formatter": { "quoteStyle": "double" } },
"assist": { "enabled": true, "actions": { "source": { "organizeImports": "on" } } }
}
.golangci.yml
version: "2"

linters:
default: standard

formatters:
enable:
- gofmt
- goimports

The OpenTofu module needs no config: tofu fmt, tofu validate, and trivy config are already in the lint task. Fix the starter's Python issue and re-run:

mise exec -- ruff check --fix services/api
mise run check

Measured on the fixed repo: lint and tests finish together in about 11 s and the exit code is 0.

$ mise run check
[lint] $ ruff check services/api
[lint] All checks passed!
[lint] $ ruff format --check services/api
[lint] 4 files already formatted
[lint] $ biome check web
[lint] Checked 3 files in 24ms. No fixes applied.
[lint] $ cd cli && golangci-lint run ./...
[test] Ran 2 tests in 0.005s
[test] OK
[test] ✔ formats euro cents
[lint] $ tofu fmt -check -recursive infra
[lint] $ tofu -chdir=infra/modules/bucket init -backend=false -input=false
[lint] $ tofu -chdir=infra/modules/bucket validate
[test] ok example.com/shop/cli (cached)
[test] Finished in 2.14s
[lint] $ trivy fs --scanners vuln,secret,misconfig --severity HIGH,CRITICAL --exit-code 1 --quiet .
[lint] $ gitleaks dir . --no-banner
[lint] Finished in 10.40s
Finished in 10.45s
$ echo $? # exit code
0

Spot checks of the individual tools:

$ golangci-lint config verify && cd cli && golangci-lint run ./...
0 issues.
$ tofu -chdir=infra/modules/bucket validate
Success! The configuration is valid.
$ gitleaks dir . --no-banner
no leaks found

To see trivy config earn its place, scan a deliberately weak module outside the repo (a bucket with no public access block and SSH open to the world):

$ trivy config --severity HIGH,CRITICAL /tmp/badtf
main.tf (terraform)
Tests: 6 (SUCCESSES: 0, FAILURES: 6)
Failures: 6 (HIGH: 6, CRITICAL: 0)
AWS-0086 (HIGH): No public access block so not blocking public acls

An agent reading this output knows exactly which resource to fix. That is the property you are buying.

Tool versions in the transcript

Outputs above come from ruff 0.17.2, biome 2.6.2, golangci-lint 2.15.0, trivy 0.76.1, OpenTofu 1.13.2, gitleaks 8.30.1, all installed by mise (see step 1). Trivy flags: secret scanning and misconfiguration scanning.


Step 3: AGENTS.md, with CLAUDE.md importing it​

Theory: AGENTS.md, CLAUDE.md, and Rules, Context Engineering. Lever: context.

Write the file an agent needs on every task and nothing else: the verify command, the conventions it cannot infer, and the boundaries.

AGENTS.md
# shop

Polyglot demo: Python API (`services/api`), TypeScript client (`web`), OpenTofu module
(`infra/modules/bucket`), Go CLI (`cli`).

## Verify (run before you say you are done)
- `mise run check` runs lint and tests for every language. It must pass.
- Fix lint with `ruff check --fix services/api`, `biome check --write web`, `tofu fmt -recursive infra`.

## Conventions
- Money is integer cents. Never use floats for stored amounts.
- Python 3.13, stdlib `unittest`. TypeScript runs on Node's built-in test runner, no extra deps.
- Do not add a dependency without asking. Run `trivy fs .` after any dependency change.

## Boundaries
- Never read or edit `.env*` files. Use `.env.example` for variable names.
- Plans for multi-step work live in `docs/plans/<epic>/`. Scratch notes go in `scratchpad/` (git-ignored).
- After a behavior change, run the `post-change-update` skill.
CLAUDE.md
@AGENTS.md

Claude Code reads CLAUDE.md; the @AGENTS.md import pulls the shared file in, so Codex, OpenCode, and Cursor read the same text natively (Claude Code memory docs). A symlink also works but breaks on Windows checkouts. The file is 18 lines; the docs target under 200 per file. Ask of each line: would removing it cause a mistake?


Step 4: Pre-commit with prek​

Theory: Hooks, Pre-commit, and Quality Gates. Lever: guardrails.

Pre-commit is the guard that works for every harness and every human. prek reads the standard .pre-commit-config.yaml; plain pre-commit works with the same file.

.pre-commit-config.yaml
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
rev: v0.17.2
hooks:
- id: ruff-check
args: [--fix]
- id: ruff-format
- repo: https://github.com/biomejs/pre-commit
rev: v2.6.2
hooks:
- id: biome-check
- repo: https://github.com/gitleaks/gitleaks
rev: v8.30.1
hooks:
- id: gitleaks
- repo: local
hooks:
- id: tofu-fmt
name: tofu fmt
entry: tofu fmt -recursive infra
language: system
pass_filenames: false
files: \.tf$
git add -A
uvx prek install
uvx prek run --all-files

Measured with prek 0.5.7 (first run clones and builds hook environments, 61 s; later runs are fast):

ruff check...............................................................Passed
ruff format..............................................................Passed
biome check..............................................................Passed
Detect hardcoded secrets.................................................Passed
tofu fmt.................................................................Passed

pre-commit 4.7.0 was available through uvx pre-commit but the hook run itself was only measured with prek. golangci-lint ships its own hook ids (golangci-lint, golangci-lint-fmt) in its repo; add them if your repo has Go. The tofu-fmt hook above is a local hook, so it needs no unverified third-party rev.


Step 5: Claude Code hooks: format after edit, guard .env​

Theory: Hooks, Pre-commit, and Quality Gates. Lever: guardrails + feedback.

Two hooks. PostToolUse runs after every Write or Edit: it formats the file, lints it, and returns remaining errors to the agent with exit code 2. PreToolUse runs before any tool use and blocks .env access with exit code 2. Hook input arrives as JSON on stdin; the edited path is tool_input.file_path (hooks reference).

.claude/hooks/format.sh
#!/usr/bin/env bash
# PostToolUse (Write|Edit): format the edited file, then lint it. Exit 2 feeds lint errors back to the agent.
set -uo pipefail
f=$(jq -r '.tool_input.file_path // empty')
[ -n "$f" ] && [ -f "$f" ] || exit 0
run() { mise exec -- "$@"; }
case "$f" in
*.py)
run ruff check --fix --quiet "$f" >/dev/null 2>&1
run ruff format --quiet "$f"
out=$(run ruff check "$f" 2>&1) || { echo "$out" >&2; exit 2; } ;;
*.ts|*.tsx|*.js|*.json)
out=$(run biome check --write "$f" 2>&1) || { echo "$out" >&2; exit 2; } ;;
*.go) run gofmt -w "$f" ;;
*.tf) run tofu fmt "$f" >/dev/null ;;
esac
echo "formatted: $f" >&2
exit 0
.claude/hooks/guard-env.sh
#!/usr/bin/env bash
# PreToolUse (Read|Edit|Write|Bash): block access to .env files. Exit 2 = blocked, reason goes to the agent.
set -uo pipefail
input=$(cat)
target=$(jq -r '.tool_input.file_path // .tool_input.command // empty' <<<"$input")
if grep -Eq '(^|[/[:space:]])\.env($|[.[:space:]"'"'"'])' <<<"$target" && ! grep -q '\.env\.example' <<<"$target"; then
echo "Blocked: .env files hold secrets. Read .env.example for variable names." >&2
exit 2
fi
exit 0
.claude/settings.json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Read|Edit|Write|Bash",
"hooks": [
{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-env.sh", "timeout": 10 }
]
}
],
"PostToolUse": [
{
"matcher": "Write|Edit",
"hooks": [
{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/format.sh", "timeout": 30 }
]
}
]
}
}
chmod +x .claude/hooks/*.sh

Test both scripts without an agent by piping the JSON a hook would receive. Measured:

$ printf 'import os\ndef f( x ):\n return os.getcwd( )\n' > services/api/app/tmp.py
$ echo '{"tool_input":{"file_path":"'$PWD'/services/api/app/tmp.py"}}' | .claude/hooks/format.sh
formatted: /tmp/agent-ready-lab/shop/services/api/app/tmp.py (rc=0)
$ cat services/api/app/tmp.py
import os


def f(x):
return os.getcwd()

$ printf 'def f(x):\n return undefined_name\n' > services/api/app/tmp.py
$ echo '{"tool_input":{"file_path":"'$PWD'/services/api/app/tmp.py"}}' | .claude/hooks/format.sh
F821 Undefined name `undefined_name`
--> services/api/app/tmp.py:2:12
Found 1 error. (rc=2)

$ echo '{"tool_input":{"file_path":"/x/shop/.env"}}' | .claude/hooks/guard-env.sh
Blocked: .env files hold secrets. Read .env.example for variable names. (rc=2)
$ echo '{"tool_input":{"command":"cat .env.local"}}' | .claude/hooks/guard-env.sh (rc=2)
$ echo '{"tool_input":{"file_path":"/x/shop/.env.example"}}' | .claude/hooks/guard-env.sh (rc=0)

The scripts were verified this way. Their behavior inside a live Claude Code session was not measured. In a session, a PostToolUse exit 2 does not undo the edit (the tool already ran); stderr is shown to the agent so it can fix the error. PreToolUse exit 2 blocks the call (exit code semantics).

Other harnesses

OpenCode implements the same ideas as JS plugins (tool.execute.before and tool.execute.after in .opencode/plugins/), Codex reads .codex/hooks.json. Pre-commit from step 4 covers all harnesses. See Agent Harnesses.


Step 6: A project skill​

Theory: Skills and Skill Creation. Lever: context.

Anything you repeat at the end of every task but do not want in AGENTS.md on every turn belongs in a skill. Only the short description loads at startup; the body loads when the skill is used.

.claude/skills/post-change-update/SKILL.md
---
name: post-change-update
description: Refresh docs and notes after a code change is verified. Use when a feature, fix, or refactor in this repo is finished and `mise run check` passes, or when the user says "wrap up" or "update docs".
---

# Post-change update

Run these steps in order after `mise run check` passes. Skip a step that does not apply.

1. List what changed: `git diff --stat main`.
2. If behavior or a public function changed, update the matching section of `README.md` or `docs/`.
3. If you made a design decision, add one line to the `Decision log` in the active plan under `docs/plans/`.
4. Tick finished tasks in the plan file and add one line under `Progress` with today's date.
5. If a new command or convention is needed by every future session, add one line to `AGENTS.md`. Keep it under 60 lines.
6. Delete or archive `scratchpad/` notes that are now in the plan or the docs.
7. Report: files changed, docs updated, anything left open.

The directory name must match name; the description says what the skill does and when to use it (skills docs, agentskills.io spec). Commit it: .claude/skills/ is the project scope.


Step 7: Scratchpad and execution plans​

Theory: Scratchpads, Memory, and Knowledge Bases, Execution Plans. Lever: context.

Two locations, two lifetimes. scratchpad/ is one session's working notes and is git-ignored (step 0 already added it to .gitignore). docs/plans/<epic>/ is durable: an epic README that sequences plans, and one file per plan that fits in one session. The plan sections follow the OpenAI ExecPlan format in reduced form: Purpose, Progress, Decision log, Validation.

docs/plans/pricing-v2/
README.md epic: goal, plan table, order
01-api-discounts.md plan 1: tests first, then implement
02-web-display.md plan 2: reads plan 1's decision log
scratchpad/README.md git-ignored, per-session notes
docs/plans/pricing-v2/README.md
# Epic: pricing v2

Goal: discounts in the API, formatted in the web client, with a tested rollout.

| Plan | Scope | Status | Verify |
|---|---|---|---|
| [01-api-discounts.md](./01-api-discounts.md) | `services/api`: percentage discount on `total_cents` | todo | `mise run check` |
| [02-web-display.md](./02-web-display.md) | `web`: show discounted price | todo | `mise run check` |

Order: 01 before 02. Each plan runs in its own session; start it with `/clear`.
Shared decisions go in the Decision log of the plan that made them.
docs/plans/pricing-v2/01-api-discounts.md
# Plan 01: API discounts

## Purpose
`total_cents(items, tax_rate, discount_pct)` applies a percentage discount before tax.

## Progress
- [ ] Add failing tests (0 percent, 10 percent, 100 percent, negative rejected)
- [ ] Implement `discount_pct` (default 0)
- [ ] `mise run check` passes

## Decision log
- (none yet)

## Concrete steps
1. Edit `services/api/tests/test_pricing.py` first.
2. Edit `services/api/app/pricing.py`. Round once, at the end.

## Validation
`mise run check` exits 0. `total_cents([{"price_cents": 1000, "qty": 2}], discount_pct=10)` returns 2160.
docs/plans/pricing-v2/02-web-display.md
# Plan 02: web display

## Purpose
`formatPrice` can render a struck-through original price next to the discounted one.

## Progress
- [ ] Read the Decision log of plan 01 for the final API shape
- [ ] Add `formatDiscount(originalCents, discountedCents)` with a test
- [ ] `mise run check` passes

## Decision log
- (none yet)

## Validation
`mise run check` exits 0.

Each plan ends with a validation line the agent can run: mise run check. That ties the plan to the feedback loop from step 1.


Step 8 (optional): AWS Documentation MCP server​

Theory: MCP Servers. Lever: context.

If the client works on AWS, give the agent current AWS docs instead of training-data memory. Project scope writes .mcp.json at the repo root so teammates share it (MCP docs). Requires uv and Python 3.10 or newer (server README).

.mcp.json
{
"mcpServers": {
"awslabs.aws-documentation-mcp-server": {
"command": "uvx",
"args": ["awslabs.aws-documentation-mcp-server@latest"],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR",
"AWS_DOCUMENTATION_PARTITION": "aws"
}
}
}
}

This file was written but the server was not started in the authoring sandbox (not measured). Claude Code asks for approval the first time it sees a project-scoped server. The README uses @latest; for a client engagement pin an exact version instead (see MCP Servers on pinning). Add only servers the task needs; each one costs context tokens.


Step 9: Run an agent against it​

Theory: Context Engineering, Execution Plans. All levers. This step needs an interactive Claude Code session and was not measured.

Commit your work so far (git add -A && git commit -m "chore: agent-ready"), then start the agent in shop/:

claude --permission-mode plan

Session 1: plan 01. Paste:

Read docs/plans/pricing-v2/README.md and execute 01-api-discounts.md.
Write the tests first and show me they fail. Then implement.
Keep notes in scratchpad/. Update the plan's Progress as you go.

What to observe:

You should seeIt proves
The agent reads AGENTS.md content via the CLAUDE.md import (check with /memory)Context lever loaded
It runs mise run check after edits and again at the endThe verify command in AGENTS.md was followed
formatted: ...py on stderr after each edit, or a ruff error it then fixesPostToolUse hook is live
A refused attempt if you ask it to "show me the .env file"PreToolUse guard is live
The post-change-update skill invoked when it finishes (or run /post-change-update)Skill is discovered
01-api-discounts.md Progress boxes ticked, a Decision log linePlan is the durable state

If a step is skipped, do not repeat yourself. Make the agent's fix permanent: add one line to AGENTS.md, or promote the rule to a hook.

Session 2: plan 02, fresh context. Run /clear, then:

Read docs/plans/pricing-v2/README.md and execute 02-web-display.md.
Use the Decision log of plan 01 for the API shape.

The second session starts with an empty context window, loads only AGENTS.md and the two plan files, and still has everything it needs. That is the payoff of writing plans to disk: no /compact, no stale history, no attention loss (Context Engineering).


What you built​


Checklist​

  • mise run check exits 0 and is the first line in AGENTS.md under "Verify"
  • All tools pinned in mise.toml; no tool is required that mise does not install
  • Ruff, Biome, golangci-lint config files committed; tofu fmt, validate, trivy, gitleaks in the lint task
  • AGENTS.md under 60 lines; CLAUDE.md contains only @AGENTS.md
  • .pre-commit-config.yaml committed and prek run --all-files passes
  • .claude/settings.json has PostToolUse (format) and PreToolUse (.env guard); scripts are executable and tested with piped JSON
  • .claude/skills/post-change-update/SKILL.md committed, name matches directory
  • scratchpad/ git-ignored; docs/plans/<epic>/ has a README and one file per plan
  • (Optional) .mcp.json committed with the AWS Documentation MCP server
  • Agent session run: it called mise run check, hooks fired, /clear then plan 02 worked

Cleanup​

cd .. && rm -rf shop ~/agent-ready-lab # the lab repo
rm -rf /tmp/badtf # the weak-module demo
mise uninstall --all 2>/dev/null || true # optional: remove tools mise installed
uvx prek uninstall # only if run inside a repo you keep

Sources​

All versions "as of 2026-10-22".