A production-minded Claude Code template for new and established repositories.
Turn agent-assisted development into an inspectable path from project context to verified, explicitly authorized delivery.
Use this template · Adopt into an existing repo · Explore the visual playbook · Review the security model
Important
anthropicon improves the development process; it does not make an unfinished application production-ready by itself. Every project must still supply and verify its own architecture, security, data, operations, and release evidence.
| Create a new project | Adopt into an established repository |
|---|---|
| Begin with a clean template, define the product before the stack, then initialize only what the project needs. | Inspect compatibility first, preserve project-owned work, and apply only reviewed Claude Code surfaces. |
| Create from the GitHub template → | Read the adoption guide → |
anthropicon is intentionally not an application starter or a framework opinion. It gives Claude Code durable operating rules, progressive workflows, canonical checks, and clear authority boundaries—then leaves product and technology choices to the evidence in the project.
| Durable context | Deliberate execution | Verifiable delivery |
|---|---|---|
CLAUDE.md holds the small set of rules that should always be present. Detailed rules, skills, agents, and project facts load only when relevant. |
Clear work stays lightweight. Ambiguity, architecture, experience, and production risk receive the process they need. | Local commands, reviewed hooks, Git hooks, and CI share the same canonical verification path. |
| Less repeated discovery | Less process without less rigor | Less room for stale confidence |
The template also keeps external context in its proper place: integrations begin disabled, tools remain narrowly scoped, and content from issues, webpages, documents, or tool output cannot grant authority for writes.
- Know the ground. Adopt safely or define the product outcome before selecting technology.
- Choose the work. Route each request through the smallest workflow proportionate to uncertainty and risk.
- Prove the result. Run the repository's canonical checks and invalidate stale evidence after writes.
- Cross the boundary deliberately. Commits, pushes, deployments, messages, spend, and production changes require explicit authority.
| Coverage | Current baseline |
|---|---|
| Repository state | New repositories and conflict-preserving adoption into established repositories |
| Verification | Equivalent POSIX and native Windows setup and verification entry points |
| Continuous integration | Ubuntu across Python 3.10 and 3.13, with project-specific checks added during initialization |
| Claude Code surfaces | CLAUDE.md, .claude/rules/, .claude/skills/, .claude/agents/, .claude/commands/, and .claude/settings.json |
| Updates | Deliberate local review, explicit diffs, and rollback through ordinary Git history |
- Select Use this template and create a repository.
- Install and authenticate Claude Code, then open the new repository at its root with
claude. - Review
CLAUDE.md,.claude/rules/,.claude/skills/, and.claude/settings.jsonbefore trusting the project configuration. - Verify the baseline:
python scripts/verify.py --quick
python scripts/verify.pyOn Windows, use the same Python commands or scripts/verify.ps1. On POSIX systems, ./scripts/setup.sh configures the repository-local Git hooks and runs the quick gate.
- Define the project:
/discover
We need to solve [problem] for [specific user].
Success means [observable outcome].
Constraints: [real constraints].
Out of scope: [non-goals].
- Initialize the real stack after approving the brief:
/init Configure this repository from the approved brief. Recommend the
smallest suitable stack, replace every template command with a real one,
configure equivalent CI checks, and explain any irreversible choice before
making it. Do not add hosting or deploy anything unless I ask.
Keep anthropicon and the target repository separate, then begin with a read-only inspection. Create a branch, review the existing CLAUDE.md, .claude/ surfaces, CI, hooks, scripts, and contributor guidance, and identify project-owned files before copying anything.
Copy only the surfaces the project can own and maintain. Merge existing guidance manually when both sides contain real policy. The template never grants permission to overwrite project-owned files, create secrets, deploy, or contact a provider.
Continue with the adoption playbook and run the target repository's own checks alongside the applicable anthropicon checks.
The repository exposes compact skill metadata first. Complete instructions load only when a task needs them.
| Stage | Use when | Primary workflows | Evidence before continuing |
|---|---|---|---|
| Adopt | An established repository needs the template | Adoption playbook | Reviewed compatibility plan and conflicts |
| Define | The product or behavior is not settled | /discover |
Approved brief or executable specification |
| Build | The outcome is clear enough to implement | Outcome-based prompts and project commands | Observable behavior and focused verification |
| Assure | Correctness, security, architecture, or release risk needs scrutiny | /review, /verify, and the reviewer or verifier agent |
Findings resolved and canonical checks passing |
| Deliver | A specific Git or external effect is authorized | /release |
Only the requested commit, push, pull request, or deployment |
| Situation | Use |
|---|---|
| New or unclear project | /discover → /init |
| Clear change affecting a few files | An ordinary outcome-based prompt, then /verify |
| Unclear feature behavior | /discover before implementation |
| Expensive-to-reverse technical choice | /review with an architecture-focused request |
| Engineering correctness or regression review | /review or the reviewer agent |
| Fresh repository evidence | /verify or the verifier agent |
| Explicit commit, push, pull request, or deployment request | /release |
Skills are routing tools, not mandatory ceremony. Claude Code may select one automatically; name one when you want that exact workflow.
The examples use Matchday, a fictional community-football app:
/discover
We want a mobile-first app for community football supporters to follow
fixtures, live scores, standings, and match alerts. Success means a supporter
can find today's match and understand its current state in under 10 seconds.
Constraints: accessible web app, no betting features, no data provider chosen.
/init Configure Matchday from the approved brief. Recommend the smallest
stack for a responsive web app with live-score updates. Create real setup,
development, lint, test, security, and CI commands. Do not initialize hosting
or contact providers.
Add the upcoming-fixtures view using the existing API boundary.
Done when each fixture shows competition, teams, kickoff in the viewer's
timezone, and complete loading, empty, and error states. Add focused tests and
run the repository checks. Local code changes only.
Before the first real launch:
/review Audit this release across authorization, tenancy, data, privacy,
dependencies, provider failure, abuse controls, observability, capacity,
backups, restore evidence, migrations, rollback, and incident ownership.
Do not deploy or accept risk on my behalf.
Want the whole system at a glance? The operating playbook maps the lifecycle stages, Claude Code surfaces, safety boundaries, example prompts, and evidence gates.
anthropicon treats safety as a chain of independent controls, not a single prompt.
| Layer | What it contributes |
|---|---|
| Repository policy | Forbids opening credential-bearing files, dumping environment variables, and inferring external authority. |
| Claude Code hooks | Block common credential reads, ask about destructive shell patterns, and require quick verification before stopping. |
| Canonical verification | Checks tracked structure, metadata, Python syntax, placeholders, and repository name hygiene without printing suspected secret values. |
| Git and CI checks | Offer opt-in local gates and repeat verification on clean runners. |
| Release review | Treats missing authorization, recovery, rollback, or operational ownership as a release gap. |
Project hooks run only after the user reviews and trusts them. Repository code cannot grant that trust on the user's behalf. Optional MCP servers and other integrations remain disabled until their instructions, data boundaries, tool scope, and approval mode have been reviewed.
anthropicon reduces recurring context without weakening engineering work:
CLAUDE.mdstays short and durable.- Skill metadata is visible before full workflow instructions are loaded.
- Rules, skills, agents, and commands each have one clear responsibility.
- Tool output is targeted; delegation is used only when it offsets its own context cost.
/verifyshortens the path to fresh evidence without reducing implementation, review, tests, or security checks.
The template validator enforces the required native surfaces and the initial skill metadata contract.
.
├── CLAUDE.md # durable project guidance and routing
├── START_HERE.md # newcomer project-start guide
├── .claude/
│ ├── rules/ # modular conditional guidance
│ ├── skills/ # progressively disclosed workflows
│ ├── agents/ # bounded project agent profiles
│ ├── commands/ # custom slash-command entry points
│ └── settings.json # reviewed project hooks
├── .githooks/ # opt-in commit and push verification
├── .github/ # CI and collaboration defaults
├── docs/ # Claude Code guide, patterns, and playbooks
├── scripts/ # canonical cross-platform commands and hooks
└── tests/ # template and hook contract tests
- Claude Code opened at the repository root.
- Python 3.10 or newer for template validation and hooks.
- Git only when branches, commits, worktrees, remotes, or pull requests are wanted.
- Bash for POSIX scripts or PowerShell for equivalent native Windows paths.
No provider account, API key, database, hosting platform, or optional integration is required to begin.
- It does not choose a framework, database, or cloud before the project requires one.
- It does not guarantee generated code is correct, secure, accessible, or production-ready.
- It does not read credentials, create production secrets, or preconfigure third-party integrations.
- It does not download or apply automatic template updates.
- It does not authorize commits, pushes, deployments, messages, purchases, or production changes.
- It does not replace product judgment, security review, operational ownership, or human risk acceptance.
Template releases are recorded in TEMPLATE_VERSION. Projects remain independent and never receive automatic or network-fetched upgrades.
When adopting a later release, compare a trusted local source against the target branch, review conflicts, and apply only the files the project explicitly accepts. Preserve project-owned commands, guidance, architecture, and decisions. The upgrade guide explains the preservation boundaries.
Questions and reproducible problems belong in GitHub Issues after checking the support guidance. Security vulnerabilities must follow the private reporting process. Contributions are welcome under CONTRIBUTING.md and the Code of Conduct.
anthropicon is maintained by @bnet47 and released under the MIT License.