Also: claudestat-mcp-bundle (standalone MCP server for ClaudeStat) · claudestat-alert-slack (Slack alerting) · claudestat-exporter-prometheus (Prometheus exporter)

• Looking for opportunities — junior/fullstack roles with AI focus
• Maintaining claudestat and applyr — open source developer tools
• Building WodRival — a competitive fitness SaaS (CrossFit / Hyrox): every workout is scored, ranked and comparable, with live leaderboards, seasonal leagues, club management and Stripe subscriptions

All metrics tracked by ClaudeStat.

Claude Code from Zero — Amazon KDP (August 2026)
Practical guide to AI-assisted software development with Claude Code.

Spec-driven, not vibe-driven. Every feature starts as a living spec and runs through human gates that close the loop with drift detection — it's a feedback cycle, not a one-way pipeline. The spec is the source of truth; the AI implements, but my architecture and scope decisions stay human.

flowchart LR
    C[Constitution<br/>immutable rules] --> S[Specify<br/>assumptions first]
    S --> A[Assumptions Surface<br/>AI declares implicit choices]
    A --> S
    S -->|HUMAN GATE| P[Plan<br/>data-model + contracts]
    P -->|contracts LOCKED| T[Tasks<br/>atomic, test-first]
    T -->|HUMAN GATE| I[Implement<br/>AI, constrained by spec]
    I --> V[Validate<br/>traceability + drift]
    V -->|drift found| AM[/Amend<br/>same command, auto-detected/]
    AM --> S
    V -->|low risk| M[PR → Merge]
    V -->|high risk| X[Adversarial Verify<br/>fresh context, contract only]
    X -->|defect found| AM
    X -->|no defect| M

Without a spec, the AI makes thousands of micro-decisions silently. With one, those decisions are made explicitly by me — before a single line of code — and validated instead of trusted.

Not tied to one vendor's magic, either: I run this pipeline in two different AI coding tools side by side, from one shared template source — a feature can start in one and finish in the other without translating anything.

flowchart LR
    T[("Shared templates<br/>constitution · spec · plan · tasks")]
    T --> CC["Claude Code — /sdd"]
    T --> OC["OpenCode — /sdd"]
    CC <-.->|same repo,<br/>same spec files| OC

MoSCoW priorities — every acceptance criterion is one of these:

The tradeoff I accept:

• + An extra hour writing a spec saves three days of agent thrash (GitHub Engineering)
• + Contracts freeze after planning — no signature drift mid-build
• + Validate catches drift early: mismatched contracts, schema, untested [MUST] ACs
• − Spec-first costs time before code exists — I skip it for one-line fixes and throwaway spikes

Tests written by whoever just read the implementation only prove the code does what it does — not what it should. That's circular verification, and it's the most common failure mode of AI-written tests.

So high-risk changes get a second pass from a verifier that runs in a fresh context and never sees the diff — only the acceptance criteria, the file paths and the public signatures. Independence is enforced structurally, not requested politely.

Findings deliberately don't block the merge: blocking creates pressure to weaken the test, which is the one thing the verifier is forbidden to do. They ship as reports and get fixed in a separate PR.

No acceptance criteria, no run — without a contract it degrades into reading the code and testing what it already does. The gate is narrow on purpose: auth · money · data integrity · migrations · state machines · idempotency · offline sync. Everything else skips it.