By the end of the AI Coach project I had a process that worked (for me at least): agents running at defined gates, documentation updating itself, tech debt tracked systematically, and Claude Code (largely) staying on track across dozens of sessions. The process was baked into that repo's structure; CLAUDE.md, process.md, build guides, agents, the lot.

The problem was that it was all buried in a single repository. Every new project would mean copying files, stripping out project-specific content, and hoping I hadn't missed a reference to something that only existed in the AI Coach codebase. So I extracted the process into a standalone GitHub template: claude-toolkit so it can be used consistently.

What the toolkit covers

The toolkit works across Claude Code and Claude Desktop/Web.

The core of it is a codified development process with custom agents, skills, git hooks, GitHub templates, and a pre-configured CLAUDE.md skeleton. Everything is modular; delete what you don't need and the rest still works.

The process flow

This is the part that came directly from the AI Coach build. During that project I learned that Claude Code works best when it has clear gates: defined points where specific agents run, findings get folded back into the branch, and the PR opens in its final state rather than accumulating fix-up commits.

There are certainly additional elements that I'll add over time but it's the right foundations for me to build off.

Pre-commit Linter (always) Pre-PR gates (conditional) Code reviewer DevOps reviewer + test gen Doc generator PR opens Clean diff Merge Phase boundary (end of build-guide phase) Codebase review Doc gen + CLAUDE.md refresh Phase acceptance PRD requirement validation Trivial-change fast path ≤ 50 lines, ≤ 2 files, no critical paths → linter only

The flow has four tiers. Pre-commit: the linter runs on every commit. Pre-PR gates: code reviewer, DevOps reviewer, test generator, and doc generator run conditionally based on what changed, with findings folded into the branch before the PR opens. Phase boundaries: codebase review and doc generator refresh CLAUDE.md and tech debt tracking at the end of each build-guide phase. Phase acceptance: the phase-acceptance agent validates every PRD requirement when a phase closes out.

The trivial-change fast path skips everything except the linter for small changes: 50 lines or fewer, two files or fewer, no critical paths touched. This prevents process overhead on smaller fixes and typo corrections.

An important detail: pre-PR gates run in parallel, not sequentially. Code reviewer, DevOps reviewer, and test generator can all fire at once. The same applies to phase-boundary agents. This made a real difference to velocity on the AI Coach project.

The agents

Nine custom agents, each with a defined purpose and model selection. The choice of model per agent is deliberate: Opus for the two that need the deepest reasoning (code reviewer and phase acceptance), Sonnet for the bulk of the work, and Haiku for the linter where speed matters more than depth.

The agents split into three groups by when they run. Always-on: the linter, running on every commit. Conditional gates: code reviewer, DevOps reviewer, test generator, and doc generator, each triggered by specific conditions (e.g. code reviewer fires on PRs over 300 lines or anything touching auth/IAM). Periodic or ad-hoc: codebase review and doc generator at phase boundaries, and code optimiser and refactorer when explicitly needed.

All agents have memory: project set, so that Claude can retain project-specific conventions and patterns discovered across sessions.

The plumbing

The rest of the toolkit is the supporting infrastructure that makes the process work:

Git hooks run locally with no external dependencies: pre-commit scans staged files for secrets (AWS keys, API tokens, private keys) and blocks files over 5MB; commit-msg validates Conventional Commits format; pre-push validates branch naming.

GitHub templates include a CODEOWNERS file, security policy, PR template with What/Why/How sections and a checklist, and structured issue templates for bugs and feature requests.

Claude Code permissions in .claude/settings.json pre-approve routine operations (git, npm, pytest, shell utilities) so Claude doesn't prompt for confirmation on every command. Project-specific permissions (AWS CLI, Terraform, uv) are commented out and ready to uncomment.

CLAUDE.md ships as a skeleton with placeholder sections for architecture, conventions, and patterns. It's the file I identified in the AI Coach blog as the single most important document in a Claude Code project; this template gives you the structure to fill in from day one.

Skills

The skills came after the AI Coach project and are still very much evolving. They're reusable thinking and writing frameworks that Claude triggers automatically based on natural language, or are manually called with the / command in the client. They work across all surfaces: Claude Code and Desktop/Web.

These are still somewhat draft and there are more to be added. They're complementary to the agents rather than part of the core process; the agents handle code quality gates while the skills handle thinking and communication patterns.

The toolkit is on GitHub as a public template.