← Back to overview

AI Setup

Not random prompting. A system.

I don't use AI in development ad hoc – I run it through a deliberately built system of four building blocks: rules, skills, agents and hooks. Each takes on a different job – together they form a traceable, automatically enforced workflow, at work and in my own projects alike.

See it live in the Agentic Infra Dashboard

Four building blocks, one system

Each building block plays a different role in the same flow – from silent convention to automated enforcement.

Rules

Baseline conventions that apply automatically in every repo – I don't have to repeat them in every prompt. One CLAUDE.md per workspace level, plus dedicated rule files per topic.

  • Code style — TS strict, PSR-12/Symfony, Vue SFC conventions
  • Git & commits — branch names, Conventional Commits, PR format
  • Security & secrets — Keychain instead of plaintext, no real keys in public repos
  • Spec-driven development — spec first, then plan, then code
  • Test-driven development — red-green-refactor is mandatory
  • Worktrees — parallel agents without file collisions

Skills

Recurring workflows I trigger with a command instead of explaining them every time. “/feature” chains the others into one complete flow.

  • /feature — chains spec → plan → tests → implementation → gates → review
  • /spec — writes the spec (problem, user stories, acceptance criteria)
  • /commit — a Conventional Commit in the workspace format
  • /worktree — sets up an isolated worktree for parallel work
  • /new-app — repo scaffold including CI and commit setup
  • /wrap-session — a structured close-out for a work session

Agents

Specialised roles with their own toolset that I use deliberately for individual steps, instead of handing one model everything at once.

  • orchestrator — breaks down multi-layer features, coordinates the other agents
  • planner — implementation plan incl. interfaces & contracts, writes no code
  • tester — writes failing tests from the plan's contracts (red)
  • implementer — makes tests pass, sticks to the quality gates
  • reviewer — checks diffs for real defects, not style
  • security — audits auth, input handling and secrets before shipping
  • data-analyst — schema, migration and query planning
  • docs — keeps README, changelog and docs in sync with the code

Hooks

Automated enforcement running in the background – not relying on discipline, but technically blocking whatever violates my own rules.

  • git-safety — blocks force-push, pushing to main, reset --hard, .env commits
  • tdd-gate — blocks git commit without a green test run, PR creation without lint/typecheck/test
  • infra-dashboard-sync — keeps the Agentic Infra Dashboard current automatically
  • stop-notify — notifies me when an agent run finishes

How a feature moves through the system

Using a non-trivial feature as the example – kicked off with a single command.

  1. 01
    Skill · /spec

    Write the spec

    Problem, user stories and testable acceptance criteria – before anything gets built. I sign off on the spec before it moves forward.

  2. 02
    Agent · planner

    Create the plan

    A layer-by-layer plan with interfaces & contracts. No code – just the decisions tester and implementer need as a binding baseline.

  3. 03
    Agent · tester

    Write tests (red)

    Failing tests written directly from the plan's contracts – without knowing the implementation.

  4. 04
    Agent · implementer

    Implement (green)

    Makes the tests pass, nothing more. Sticks to code-style and security rules.

  5. 05
    Hook · tdd-gate + git-safety

    Enforce the gate

    The commit is technically blocked if no green test run has been detected since the last change – regardless of whether I forget.

  6. 06
    Agent · reviewer + security

    Review against the spec

    Checks the diff for real defects and against the spec's acceptance criteria – not for taste.

For one-liners or trivial fixes I run this flow myself, without the full agent apparatus – the system scales with the task, not against it.