Projects
Things I’ve been building and experimenting with around AI agents and software engineering.
Autonomous Engineering Pipeline
A 4-phase AI agent pipeline that goes from feature planning and architecture review to implementation, code review, and keeping documentation up to date as the system evolves.
Feature Planning Pipeline
A multi-agent workflow for reviewing a feature before implementation starts. It brings together PM, Architect, Architecture Reviewer, and Engineer perspectives to clarify requirements, challenge architectural decisions, compare simpler alternatives, identify potential failure modes, and break the feature into implementable tasks.
Autonomous Developer Pipeline
An autonomous implementation workflow that takes an approved task through development and delivery in an isolated Git worktree. It keeps each agent within the approved scope, follows RED / GREEN TDD, runs the full test suite, and completes the workflow through CI and merge.
Code Review Skill
An AI code review workflow that checks both code quality and whether the implementation matches the original RFC and plan. It uses language-specific review rubrics and learns team conventions from GitHub PR feedback so future reviews can apply what the team has learned over time.
Evolution Log Skill
An AI workflow for maintaining an EvolutionLog.md that explains how a system changes over time and why. It builds the narrative from Git history, PRDs, RFCs, and post-mortems, organizing each change around the problem, options considered, decision, result, and what came next.
Because the narrative is generated from multiple sources, the workflow also verifies commits and file references against the repository before updating the log.
Autonomous Content Intelligence
A personal system I’ve been building to help me keep up with the things I care about without having to process everything myself. It uses multiple agents to collect and analyze content from newsletters, technical talks, discussions, and engineering articles, then filters them through a quality rubric and learns from what I find useful over time.
Knowledge Loop
The system runs across the AI tools I use and processes different content sources in parallel. Each piece of content goes through a rubric before being included, and the results are combined to identify recurring ideas and broader trends. My feedback is then used to refine what the system considers useful in future runs.
What changes when AI becomes an engineering collaborator rather than just a coding tool?
Most AI coding tools focus on helping us write code faster. I’m interested in exploring a broader question: can agents participate across the software development lifecycle — understanding requirements, reviewing architecture, implementing changes, maintaining quality, and preserving knowledge as the system evolves?
The projects above are experiments around this question. While building them, a few ideas have become increasingly important to me.
Planning matters more than code generation
Many important engineering decisions happen before implementation starts. Requirements need to be clarified, assumptions challenged, architecture reviewed, and trade-offs understood.
That’s why I started by building agents around feature planning and architecture review rather than focusing only on code generation. If an agent can implement quickly but starts from the wrong assumptions or design, writing code faster doesn’t help much.
Documentation should evolve with the codebase
Documentation becomes outdated easily when maintaining it is separate from the development workflow.
I’m exploring whether agents can help maintain living documentation that evolves alongside the codebase — capturing not only what the system looks like today, but also why decisions were made, how the architecture changed, and what we learned along the way.
Evaluation is an engineering problem
As I gave agents more responsibility, I found that generating an output was only part of the problem. I also needed a reliable way to determine whether that output was actually correct and stayed within the intended scope.
That’s why the skills I build include verification mechanisms such as rubric-based evaluation, scope enforcement, and phantom commit audits. I see evaluation and guardrails as part of the system design itself: if an agent is going to participate meaningfully in engineering work, its output needs to be verifiable.
I like understanding how things work — systems, people, and increasingly, AI.
Outside of software, I enjoy freediving, camping, and spending time outdoors. Freediving in particular has influenced how I think about engineering. Underwater, staying calm matters. You need to understand the environment, use your energy carefully, and avoid unnecessary movement.
I find myself applying a similar mindset to engineering: understand the problem first, keep things as simple as possible, and focus your effort where it actually matters.
Professional experience
You can find more about my work experience and the projects I’ve worked on through LinkedIn or my resume.