Lab: Make a Repository Agent-Ready
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.
- 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; makeCLAUDE.mda one-line@AGENTS.mdimport. - 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.
| Lever | What you add | Step |
|---|---|---|
| Feedback | mise.toml tasks, linters, tests | 1, 2 |
| Context | AGENTS.md, skill, plans, scratchpad, docs MCP | 3, 6, 7, 8 |
| Guardrails | pre-commit, PostToolUse and PreToolUse hooks | 4, 5 |
Step 0: Prerequisites and starting repo
| Item | Needed | Measured with (as of 2026-10-22) |
|---|---|---|
| git, bash, jq | yes | git 2.47.3, jq present |
| mise | yes, installs every other tool | 2026.10.17 |
| uv | for uvx prek and the MCP server | present |
| Claude Code | for steps 5, 6, 9 | not 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.
#!/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)
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.
[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:
| Tool | Pin | Source |
|---|---|---|
| python | 3.13 (3.13.17) | mise python docs |
| node | 24 (24.22.1) | mise configuration |
| go | 1.27 (1.27.3) | go.dev/dl |
| opentofu | 1.13.2 | release |
| ruff | 0.17.2 | release |
| biome | 2.6.2 | release |
| golangci-lint | 2.15.0 | release |
| trivy | 0.76.1 | release |
| gitleaks | 8.30.1 | release |
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.
[tool.ruff]
line-length = 100
target-version = "py312"
[tool.ruff.lint]
extend-select = ["B", "I", "UP"]
{
"$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" } } }
}
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.
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.
# 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.
@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.
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).
#!/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
#!/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
{
"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).
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.
---
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
# 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.
# 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.
# 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).
{
"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 see | It 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 end | The verify command in AGENTS.md was followed |
formatted: ...py on stderr after each edit, or a ruff error it then fixes | PostToolUse 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 line | Plan 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 checkexits 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,gitleaksin the lint task -
AGENTS.mdunder 60 lines;CLAUDE.mdcontains only@AGENTS.md -
.pre-commit-config.yamlcommitted andprek run --all-filespasses -
.claude/settings.jsonhas PostToolUse (format) and PreToolUse (.env guard); scripts are executable and tested with piped JSON -
.claude/skills/post-change-update/SKILL.mdcommitted, name matches directory -
scratchpad/git-ignored;docs/plans/<epic>/has a README and one file per plan - (Optional)
.mcp.jsoncommitted with the AWS Documentation MCP server - Agent session run: it called
mise run check, hooks fired,/clearthen 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".
- mise: release 2026.10.17, configuration and tasks, paranoid mode
- Ruff: 0.17.2, configuration, ruff-pre-commit
- Biome: 2.6.2, getting started, pre-commit
- golangci-lint: v2.15.0, migration guide (
version: "2") - Trivy: v0.76.1, docs
- OpenTofu: v1.13.2
- Gitleaks: v8.30.1
- Go: go.dev/dl; Node.js: nodejs.org
- prek: j178/prek (0.5.7 measured); pre-commit: pre-commit.com (4.7.0 measured)
- Claude Code: hooks, memory and AGENTS.md import, skills, MCP and scopes, permission modes
- Agent Skills spec: agentskills.io
- AWS Documentation MCP server: README
- ExecPlans: OpenAI Cookbook