dmj.one

Work / AI · Agents / Claude Kanban

No. 17 · AI · Autonomous build pipeline

Drop an idea.
Walk away.
Come back to committed code.

Most "AI coding" tools want the engineer present. The hard part of software is not the typing. It is the long, lonely back-half of an idea: the spec, the tests, the review loop, the rebase, the push. Claude Kanban does that part. By itself.

View source Quick start How the loop runs
305Automated tests passing
5Production dependencies
100API endpoints documented
9Stages per card cycle
0Build step required

Act I · The Problem

Coding tools don't let you walk away.

Pair-programming AI ships completions. But the back-half of building software, the bit that takes days, is still on you.

i.

Watch the agent. Approve every step.

Most tools demand attention at every prompt. You can't go to bed. The flywheel breaks the moment you log off.

ii.

Wire up the tests yourself.

Generated code without a feedback loop is half a tool. There is no automatic re-run, no auto-fix, no rollback when the patch breaks main.

iii.

Forget your own preferences next session.

You said "no Tailwind" yesterday. Today it added Tailwind. The model forgets. The team rolls eyes.

iv.

One bad command bricks the repo.

Without snapshots, audit logs and rollback, an autonomous agent is a liability. Most teams will not run one in production.

Act II · The Promise

A board.
An idea file.
That is the input.

Drop an idea.md in a folder. Set the mode to single-project. The orchestrator reads it as the north star. Every 30 minutes it analyses the codebase and creates improvement cards. Each card flows through the full nine-stage cycle. No human required.

Act III · The Pipeline

Five moves.
Run on a loop.

  1. Step 01

    Brainstorm

    Card title in. Claude generates a spec, lists files to touch, estimates the work, surfaces risks. Snapshot taken before any byte is written.

  2. Step 02

    Build

    Claude Code SDK runs the patch in a real shell. Self-healing engine groups failures by card, scans every 30s, retries with new context.

  3. Step 03

    AI Review · 1 to 10

    A separate Claude session reviews the diff. Scores out of 10. Score 8+ ships. 5-7 triggers up to three auto-fix passes. Below 5 escalates to human.

  4. Step 04

    Commit and push

    Approved cards get a real git commit, real message, real push. Concurrency configurable. Card dependencies respected so two PRs never collide.

  5. Step 05

    Learn the rejection

    You reject a card, the orchestrator asks why. Your feedback is stored and injected into future brainstorm and discovery prompts. The board adapts.

Act IV · Trust by the numbers

Production-grade or it does not ship.

305 tests across five suites. Two-server security. Tiered backups. Argon2id passwords. AES-256-GCM encryption. CSP nonce. CSRF. Token-bucket rate limiting. WCAG 2.2 AAA on the board.

168Reliability
27Dependency audit
28Performance
35Data durability
47Code quality

Two-server design

Public board on 0.0.0.0. Admin panel locked to 127.0.0.1.

Kernel-level TCP reject on the admin port. Roles tiered superadmin then admin then user. JWT auth, AES-256-GCM field encryption. Tiered backups every 5 minutes, hourly, daily. Heartbeat watchdog. Graceful shutdown with pipeline drain.

The Stack

Five dependencies.
Zero build step.
Cross-platform start script.

  • JavaScript
  • Node.js 18+
  • Express
  • SQLite (WAL)
  • Argon2id + JWT + AES-256-GCM
  • Pino structured logs
  • Vanilla JS frontend (150KB)
  • Claude Code SDK
  • SSE live updates
  • GitHub Actions CI
  • Docker + Compose
  • Kubernetes manifests
  • GCP autoconfig (systemd + Nginx)

If a board can ship code overnight, your team can sleep.

I build autonomous AI pipelines that survive contact with production: snapshots, audits, rollbacks, role-based access, kernel-level isolation. Drop me an idea.

Hire me Back to work