AI-assisted engineering

How I build with agents.

I start with the product question: who needs this, what should change, and what could go wrong? Agents help me investigate, implement, and review. I remain responsible for the decisions and the result.

Decisions before implementation.

My workflow adapts Matt Pocock’s agent skills to the size of the change. Explore the source skills ↗

Grill
Question the user need, inspect the codebase, and challenge assumptions. Research or prototype when an answer is not yet clear.
Agreed decisions and constraints
Spec
Record the resolved behavior, boundaries, and acceptance criteria. Preserve the reasoning without restarting discovery.
A durable specification
Tickets
Split larger work into small vertical slices across the relevant layers, with dependencies and a way to verify each result.
Verifiable end-to-end tasks
Implement
Give agents bounded tasks and focused context. Build incrementally with tests, type checks, runtime feedback, and direct inspection.
Reviewable changes and checks
Code Review
Check engineering standards and requirement fidelity separately. Review the findings, exercise the result, and iterate before acceptance.
Reviewed implementation

Review, refine, repeat. Findings inform the next pass.

This is a working loop, not a documentation ceremony. A small fix may need only a clear decision and acceptance criteria; larger changes deserve a spec and tickets. Research and prototypes help when the answer is still uncertain.

Planning and verification happen throughout. I approve what is committed or released and check the deployed result; shipping is not an unattended agent decision.

A lightweight daily setup.

cmux is my daily terminal workspace. HERDR keeps CLI agents, tasks, and sessions organized in one place. I default to a lightweight terminal setup and switch to desktop tools when the task benefits from broader app or computer interaction.

Professional CLI work

Claude Code with Claude models is my usual work setup. HERDR keeps sessions and tasks visible while I move between implementation and review.

Claude Code · cmux · HERDR

Personal CLI work

Pi Agent runs OpenAI/Codex models for my personal projects, with GPT-6 Astra as my current daily driver. Pi provides the agent harness; OpenAI provides the model.

Pi Agent · cmux · HERDR

Complex desktop tasks

I use the Codex app, Claude Code on desktop, and Claude’s Cowork for tasks involving other apps, files, or supported computer interactions. I choose the environment and permissions for the task, rather than treating every chat as computer access.

Codex · Claude Code · Claude · Cowork

Inspect the work, not just the tools.

Public projects show the engineering practices and product decisions I value. These artifacts are not a claim that every change followed the same agent workflow.

Relay

Domain rules that can be checked

Relay’s public documentation identifies RSVP, queue, expense, and permission rules alongside repeatable quality commands. The decisions and checks are more useful evidence than a claim about how quickly code was generated.

Read the case study →Read the documented checks ↗

Roleway

Approval is part of the product

Roleway’s agent prepares internal changes for explicit approval. Its public documentation describes access controls and end-to-end checks. This is AI product functionality, distinct from the coding agents I use to develop it.

Read the case study →Read the security and quality notes ↗

Reusable skills. Human judgment.

I adapt shared skills and custom instructions across agents. They make recurring tasks consistent without replacing product questions or learning through the work.

Research and product decisionsClarify the problem before committing to an implementation.

grilling
Challenge assumptions, inspect the codebase, and resolve product ambiguity through questions.
research
Check primary sources and record the findings that inform a decision.
prototype
Explore uncertain interfaces, behavior, and technical approaches with disposable work.
domain-modeling
Keep domain terminology and important architectural decisions explicit.

Implementation and qualityBuild testable changes, diagnose failures, and review the result.

codebase-design
Define clear module boundaries and testing seams.
tdd
Use red-green-refactor where the agreed testing seam supports it.
diagnosing-bugs
Reproduce a failure, investigate the cause, and verify the fix.
code-review
Review engineering standards and fidelity to the originating issue or specification.
resolving-merge-conflicts
Resolve conflicts without silently discarding intended behavior.

Product and interfaceReview the experience people will actually use.

impeccable
Shape, audit, and refine interface behavior and presentation.
frontend-design
Make intentional visual decisions for new and existing interfaces.
web-design-guidelines
Check accessibility, interaction, and web-interface practices.
vercel-react-best-practices
Review React and Next.js performance patterns.

Agent operationsMake instructions reusable and execution inspectable across agents.

writing-for-agents
Maintain agent instructions and custom skills for recurring work.
agent-browser
Exercise browser flows, inspect interfaces, and capture verification evidence.
wizard
Guide human-only setup and configuration steps explicitly.

What I remain accountable for

Keep the user need, constraints, and acceptance criteria explicit.
Give each agent a bounded task and an output I can inspect.
Check repository evidence and primary documentation instead of accepting confident claims.
Treat generated code as a proposal: run relevant tests, type checks, browser checks, and direct review.
Protect confidential employer and client information, credentials, private source, and remote-access details.
Keep tool permissions, final acceptance, commits, and release decisions under human control.

Models and supporting tools.

The model, agent harness, and workspace serve different purposes. I choose each for the context rather than treating one setup as universal.

Professional work

Claude models

My usual model family for professional development with Claude Code. I choose the model and interface to suit the task.

Model information ↗

Personal-project daily driver

GPT-6 Astra

My current daily driver for personal projects. Pi Agent is my lightweight CLI harness for OpenAI/Codex models; I also use the Codex app and ChatGPT as the task requires.

Model information ↗

Research and decisions

Question assumptions, compare approaches, and learn enough to make an informed product or engineering decision.

ChatGPT · Claude

Editing and inspection

Navigate the code, use assistance where useful, and inspect changes directly in context.

Cursor · VS Code · GitHub Copilot

Voice input

Dictate prompts, questions, and notes with Wispr Flow. It is an input layer, not the agent making the decisions.

Wispr Flow

Remote access

Use Termius for remote terminal access to my Mac and HERDR workspace. I also continue supported Claude and Codex sessions through their native remote features; terminal access and remote-agent control are different tools.

Termius · HERDR · Claude Code · Codex