How I Work
I practice agentic engineering. AI accelerates the implementation, but human judgment owns the beginning and the end. The longest stages in my process are the ones that require understanding: designing the right thing to build, and reading every line of code before it ships.
I start with Claude Code skills. I create a skill for backend development that covers my design standards, and a skill for frontend development that does the same. Also, I create a skill for test-driven development. That way there are no questions about how to implement something, the code is consistent, and the file structure is predictable.
I'm using the Compound Engineering approach and plugin. The idea is the same as compound interest... small, consistent investments in the process lead to exponential improvements over time. Every unit of work is an opportunity to learn and make the next one better. The compound engineering plugin doesn't do TDD out of the box, but my skill enforces it.
Collaborative Design
PRD iterations with Opus until it's solid
Every feature starts with a conversation. I brainstorm with Claude Opus, going back and forth until the scope is clear, the edge cases are covered, and we both agree on what "done" looks like. This is where the thinking happens. The artifact that comes out of this is a PRD that guides the implementation and serves as a reference point for the code review.
Structured Planning
ce:plan approve before any code is written
The PRD becomes a concrete implementation plan with defined steps, file-level changes, and dependency ordering. I review and approve the plan before a single line of code gets written. No plan, no code.
Test-Driven Development
ce:work with CATCHES annotations
Tests get written first. Every test includes a CATCHES annotation describing the specific bug it prevents, no tests that just exercise the mock library. The implementation follows the tests, not the other way around.
Manual Testing
Feature walkthrough
Once the tests pass, I do a hands-on walkthrough of the feature to catch the things automated tests miss: visual issues, workflow gaps, edge cases that only surface when you actually use the thing.
Automated Review
ce:review + resolve todos
An automated review surfaces bugs, security issues, and code quality problems. It generates prioritized todos that I triage — deciding what gets fixed now, what gets deferred, and what gets dismissed.
Human Code Review
Read every line of code and every test
This is the other stage where I invest the most time. I read every line of code and every test in the PR. Even when the implementation code is complex, I can grasp what each test asserts, and if the tests make sense, the code has a contract I can verify.
Merge & Memorialize
ce:compound — learnings feed the next cycle
After merge, I capture what worked, what didn't, and what the system learned. These learnings feed directly into the next feature cycle, so the process gets better over time.
Why this is my philosophy
AI can write code faster than I can, but writing code is not the hard part. The difficult part is knowing what to build and being confident that what is shipped actually works, is high quality, and is maintainable. My process puts human judgment where it counts, at the design stage and in the code review, while letting AI handle the implementation (with guardrails).
Every PR I merge, I can explain. Every test I approve, I understand what it catches. Every feature I ship, I know why it exists. That's my agentic engineering process.