Skip to content
Alper Sarper
AI-assisted engineering

How I build with AI agents

These are the four workflows I use with AI agents, including the one this site was built with.

Multi-agent PR loop

One Claude Code session orchestrates while implementer and reviewer subagents do the work, each feature in its own git worktree. This website was built this way.

Fig. 1 — Orchestrator → parallel implementers → PR → fresh reviewer → findings → merge
Multi-agent PR loop: an orchestrator session runs independent features in a parallel wave of implementer subagents, each in its own git worktree and branch. Each implementer opens a pull request, which a fresh reviewer subagent with no prior context reviews. Findings go back to the implementer to apply; once they are applied the orchestrator squash-merges, deletes the branch and worktree, and verifies that main builds. PARALLEL WAVE Orchestratorplan · waves Implementer Aworktree · branchImplementer Bworktree · branchImplementer Cworktree · branch Pull requestbuild · check Fresh reviewerno prior context Findingsfile:line · must-fix apply · rebase applied Squash-mergeby orchestrator delete branch + worktree verify main builds

How it runs

  1. The orchestrator plans the features and runs independent ones in parallel waves.
  2. Each feature goes to an implementer subagent in its own git worktree and branch. It opens a PR and has to pass npm run build, astro check and screenshot checks at several widths.
  3. A fresh reviewer subagent with no prior context builds the branch, takes screenshots and returns findings with file:line references, each marked must-fix or nice-to-have.
  4. Every finding goes back to the implementer, which rebases onto main if needed and applies it.
  5. The orchestrator squash-merges, deletes the branch and worktree, and verifies that main still builds.

Caught in review · this site's build

  • Low-contrast text
  • A CMS-schema mismatch that would have broken builds
  • Hard-coded social links
  • An over-engineered slot mechanism, replaced with a typed prop

Rules

  • Fresh context for review

    The reviewer starts with no prior context. It builds the branch, takes screenshots and returns findings with file:line references.

  • Rules live in reviewer briefs

    Team rules, such as the text-contrast rule, are enforced through the reviewer briefs.

  • Checks the implementer must pass

    npm run build, astro check and screenshots at several widths.

  • One worktree per feature

    Each implementer works in its own git worktree and branch.

no-mistakes pipeline

no-mistakes is an open tool by kunchenguid — I use it, I didn't build it. Agent changes go through review, tests and lint before they're pushed; I run it on Ingot.

no-mistakes on GitHub (opens in a new tab)
Fig. 2 — Change → intent · rebase · review · test · docs · lint → push · PR · CI → remote
no-mistakes pipeline: an agent's change passes through intent, rebase, automated code review, test, document and lint steps, then push, pull request creation and CI, before it reaches the remote. Findings stop at gates, where the driving agent approves, fixes or skips them. NO-MISTAKES PIPELINE Agentchange IntentRebaseReviewTestDocsLintPushPRCI findings stop at gates: approve · fix · skip Remoteafter the gate

What it gives me

  • Agents check their own work

    Agents run their changes through the gate instead of pushing directly.

  • Review, tests, lint, docs

    Automated code review, tests, lint and docs run before the push, the PR and CI. A finding pauses the run until the agent approves, fixes or skips it.

A second brain for engineering work

A notes vault with a dashboard. Project notes record their status, where I left off and the next step. An on-demand vault agent does the note work and reports back, and session metrics are regenerated after every session.

Fig. 3 — Main session → vault agent → notes vault → dashboard; each session → metrics
A second brain for engineering work: the main session delegates note work to a vault agent started on demand, which reads and writes the notes vault and reports back. The vault holds project notes (status, where I left off, next step), learning notes and tasks, rolled up on a dashboard. After every session, metrics (active time, tokens, API-equivalent cost) are regenerated in the vault, and the dashboard reads them. Main sessionsmall context delegate report Vault agenton demand NOTES VAULT read · write Projectsstatus · next step Learningnotes Taskscreated · done Dashboardwhere I left off Session endevery session Metricstime · tokens · cost regenerate

What it gives me

  • Where I left off

    Each project note records its status, where I left off and the next step, rolled up on one dashboard.

  • A small main context

    Note work goes to a vault agent started on demand. It reports back, so the main session's context stays small.

  • Session time and cost

    Metrics are regenerated per session: active time, tokens and API-equivalent cost.

AI decision logs

On take-home and case work, I log every prompt and every AI mistake I catch, and write down each trade-off — options, decision, evidence — so I can defend it in review.

Fig. 4 — Prompt → proposal → approval → implementation; logs compiled into a report
AI decision logs: each prompt is logged verbatim, the AI proposes, a human approves, and only the approved step is implemented. Prompts, trade-offs and caught AI mistakes are logged; the trade-offs are compiled into a decision report, and the prompt and mistake logs into an appendix on AI use. next small step Prompt ProposeAI · options Approvehuman Implementapproved step only LOGS Prompt logverbatim Trade-offsoptions · evidence Mistake logAI errors caught compile Decision report AI appendixprompts · mistakes

Rules

  • Verbatim prompt log

    Every prompt is logged word for word, along with the mistakes the AI made that I caught.

  • Trade-offs written down

    Each comparison records the options, pros and cons, the decision and the evidence.

  • Compiled at the end

    The trade-offs become one report, and the prompt and mistake logs an appendix on how AI was used.

  • Small approved steps

    The AI proposes first; only the approved step gets implemented.