Loading
Back to portfolio
Practice · Agentic workflow
Building with agents.
I build with agentic AI doing the heavy lifting under a tight operating contract. Five parts: a loop every task runs, a library of reusable engineering skills, the principles that keep an agent honest, the tool stack it reaches for, and one of those principles caught in the act on this site’s own work.
01 · The loop
Every task runs the same loop.
- 01
Specify
Pin the intent before any code.
- 02
Plan
Order the work; surface the trade-offs.
- 03
Build
Small, test-first increments.
- 04
Verify
Review, debug, harden, measure.
- 05
Ship
Gate, launch, document.
- 06
Learn
Retro feeds the next loop.
the retro feeds the next loop. It is a cycle, not a line.
02 · The skills
An operating system of skills.
21 reusable skills, one per recurring engineering job, grouped by loop phase.
01Specify
Turn a fuzzy ask into a contract before a line of code.
Spec-driven development
A spec before the code.
spec-driven-developmentPlanning & task breakdown
Specs become ordered tasks.
planning-and-task-breakdownIdea refine
Diverge, then converge.
idea-refineContext engineering
Tune the agent's working context.
context-engineeringAPI & interface design
Stable boundaries, public surfaces.
api-and-interface-design
02Build
Implement in small, reversible, test-backed steps.
Test-driven development
Tests drive the code.
test-driven-developmentIncremental implementation
Ship changes one step at a time.
incremental-implementationSource-driven development
Ground decisions in official docs.
source-driven-developmentFrontend UI engineering
Production-quality interfaces.
frontend-ui-engineeringCode simplification
Clarity without changing behavior.
code-simplification
03Verify
Prove it works and that it cannot be made to break.
Code review & quality
Multi-axis review before merge.
code-review-and-qualityDebugging & recovery
Systematic root-cause debugging.
debugging-and-error-recoverySecurity & hardening
Harden against the obvious classes.
security-and-hardeningPerformance optimisation
Find and fix the real regression.
performance-optimizationBrowser testing
Verify in a real browser.
browser-testing-with-devtools
04Ship
Land it cleanly and leave a trail the next loop can read.
Git workflow & versioning
Disciplined branches + commits.
git-workflow-and-versioningCI/CD & automation
Automate build and deploy.
ci-cd-and-automationShipping & launch
Pre-launch checks, then launch.
shipping-and-launchDeprecation & migration
Remove and migrate safely.
deprecation-and-migrationDocumentation & ADRs
Record the decisions, not just the code.
documentation-and-adrs
Using agent skills using-agent-skills
The meta-skill: Discover and invoke the right skill for the moment. It is how the other 20 get picked.
03 · The principles
The rules that keep an agent honest.
Standing rules, distilled from a working CLAUDE.md, that an agent and I both hold every session.
01Decision markers
// WHY:, // DECISION:, // TRADEOFF: above any non-obvious block.
Future readers grep the code, not your memory.
02Two strikes
After two failed attempts on one approach, stop and present alternatives.
Stacking fixes on a wrong idea costs more than a reset.
03Approach-first
For non-trivial pivots, propose two or three options with trade-offs before coding.
Don't commit a stack from a single guess.
04Plan files
Long sessions get a plan: goal, approaches tried with outcome, next steps, and a do-not-retry list.
Stops re-trying reverted experiments across context resets.
05Commit the working state
Snapshot green before anything experimental; one experiment at a time.
A clean revert beats untangling cascaded regressions.
06Verification gates
Typecheck, build, and look at it before shipping. Revert broken changes immediately.
Report outcomes faithfully; if it failed, say so with the output.
07Scope discipline
Stick to the stated request. Adjacent improvements are suggestions, not silent drift.
The ask is the contract; surprises erode trust.
08Output discipline
No full-file dumps. Edit in place and reference path:line.
Context is finite; spend it on the work, not on echoes.
04 · The stack
The tools it can reach.
MCP servers wired in by role, so the agent can read code, search, drive a browser, and touch infra without leaving the loop.
Code intelligence
codesightgitnexus
Reasoning & coordination
sequential-thinkingclaude-peers
Web & research
firecrawltavily
Browser & 3D
playwrightcesium
This is how the site, and most of the work in it, gets built.
05 · In practice
Not aspirational: what enforcing this actually found.
The principles above are not aspirational; here is what enforcing them actually found on this site's own covers.
01Real capture beats generation, every time
Every project cover follows one order of preference: a real capture already on hand, then a new real capture, and only then a generated poster, where there is genuinely nothing to shoot. Auditing the covers against that order found most needed no generation at all.
02No generated lettering, ever
Every generation prompt for a cover on this site bans letterforms, glyphs and numerals outright, not just "text": an image model fakes type well enough to pass a glance and fail on a close look, and a cover gets looked at closely. Type is set afterward, by hand, in the site's own fonts.
03The audit that caught its own mistake
A generated cover for the Barnes Dubai LLM case study carried a bar chart of invented rental-yield figures credited to a real data provider. The same house-style audit that reviews every cover found it, and it was pulled and rebuilt. The item's own write-up credits the software with guardrails that strip fabricated figures before they reach a broker; the cover was held to the same bar its subject is.
04Cutting scope on the audit's own findings
Twenty of twenty-three planned per-project generation kits turned out, once actually audited, not to be generation tasks at all: a real capture, an existing crop, or nothing needed. They were cut rather than written out for completeness.