Closed-Loop Engineering
What happens when you stop managing product development and start letting your tools do the listening for you. Fifteen years of tooling compressed into one continuously running loop.
AI-Native Development
Exploring the future of software development in the age of AI.
Agent-Readable Markdown Is Infrastructure, Not a Feature
The web is being re-indexed by agents making decisions, not crawlers building search rankings. If your content requires JavaScript to surface, agents move on. Static markdown, a discovery layer, and explicit permissions. That's the baseline now.
Everything I Got Wrong About Building with AI (And What I Learned)
I thought AI was about output speed. It's about judgment preservation. I thought documentation was overhead. It's the primary output. Here's what I learned.
Prompt Security: The Conversation Nobody's Having
Your prompts contain business logic and competitive advantage. They're stored in plaintext by vendors who can read them. Nobody's talking about this.
Coordination Overhead Is Killing Your AI Projects
Ceremonies sized for 10 people applied to 3 people. Meeting overhead that exceeds work time. The coordination apparatus itself is now the bottleneck.
Building AI Systems Nobody Understands
You can build faster than you can understand. That's the danger. Systems that work but nobody comprehends become unmaintainable surprisingly fast.
The 30-Second Decision Record That Changes Everything
Full ADRs take 30 minutes. Decisions happen every hour. The math doesn't work. Here's a 30-second format that does.
Your AI Doesn't Have Amnesia. You Do.
AI doesn't remember previous sessions. But AI also never forgets what you tell it. The amnesia problem is your problem — you're not giving AI the context to remember.
Traditional Dev Teams Are Cosplaying Productivity
Sprints feel productive. Velocity charts look good. But output without understanding is cosplay. Real productivity includes context preservation.
The Six Principles That Changed How I Build with AI
Intent before automation. Prompts as IP. Decisions as liabilities. Risk made explicit. Memory as infrastructure. Learning that compounds.
When to Document and When to Ship
Not everything needs documentation. Some things need it desperately. Here's how to tell the difference.
Small Teams Beat Big Teams (With AI)
Two people with AI can match what ten people did before. But only if you actually reduce to two people. The coordination overhead of ten eats the gains.
Decision Intelligence > Decision Logs
Logging decisions is step one. Connecting them, learning from them, making them searchable — that's decision intelligence. Go beyond the log.
Your Process Is Optimized for 2015
The bottleneck was writing code. Now it's understanding code. Your process didn't get the memo. Time for an update.
The Role That's Missing from Every AI Team
Who preserves context? Who manages prompts? Who ensures learning compounds? Nobody. The role doesn't exist. It should.
Evidence-Based Development Isn't Optional Anymore
Without evidence, opinions stay opinions. When AI can generate anything, evidence is how you know what actually works. Measure or guess.
Heavyweight PM Is Technical Debt
Process overhead compounds like technical debt. The ceremonies you don't need slow you down every sprint. Pay down the process debt.
From Prompt Chaos to Prompt System in 30 Days
Your prompts are scattered everywhere. Here's a practical 30-day plan to collect, organize, and version them into a real system.
The Context Decay Timeline Nobody Talks About
Day 1, everyone remembers. Week 2, details blur. Month 3, only participants remember. Month 6, the reasoning is gone. Act accordingly.
The IP You're Accidentally Giving Away
Your prompts contain business logic. You store them in tools where vendors can read them. That's intellectual property exposure you may not realize.
Why Prompt Ops Tools Miss the Point
Most prompt tools focus on testing and deployment. They miss the bigger problem: prompts encode thinking that needs preservation, not just management.
Your Documentation Strategy Is Backwards
You document after shipping. By then, context is gone. Document before and during instead. The sequence matters.
Version Control for Prompts Isn't Optional
You version your code. You version your configs. Your prompts are more valuable. Version them.
ADRs Were Built for a Slower World
Architecture Decision Records take 30+ minutes. Decisions happen every hour. The format doesn't fit the pace. What fits instead?
The Prompt Library You're Not Building
Your team writes prompts every day. Where do they go? Chat logs that disappear. Personal files. Memory. You're losing institutional knowledge constantly.
Lightweight Documentation That People Actually Read
Most documentation is written once and read never. Here's how to create documentation light enough to write and useful enough to read.
The Death of the 10x Developer
The 10x developer was someone who wrote 10x more code. AI writes unlimited code. The new skill is judgment, not output. Different game entirely.
Decisions Are Liabilities, Not Assets
Every decision creates maintenance burden. Someone will need to understand, maintain, or change what was decided. Treat decisions accordingly.
The Standup That Could Have Been an Async Update
15 minutes × 5 people × 5 days = 6+ hours per week. For information that could be shared in writing. Question the ritual.
Stop Measuring Velocity. Start Measuring Understanding.
Velocity measures output. AI provides unlimited output. The new scarcity is understanding. Measure that instead.
What Comes After Agile? Nothing. That's the Point.
Stop waiting for the next framework. There isn't one. The right approach is context-dependent, evolving, and yours to figure out.
Your Team Forgets Faster Than It Learns
Every project generates learning. Most teams lose that learning within weeks. Without systems to preserve knowledge, you pay full tuition every time.
The Ticket Took Longer Than the Work
You spent 45 minutes writing a detailed ticket. AI completed the work in 10 minutes. The overhead now exceeds the work. Something is wrong.
Agile Was Never Meant for This
Agile emerged when coding was slow and requirements changed. Now coding is instant and change is constant. The original constraints are gone.
The Risk Nobody Documents in AI Systems
AI systems fail differently than traditional software. Confident wrongness, drift, encoded assumptions — these risks compound silently. Document them or suffer.
Intent Before Automation: The Mistake Everyone Makes
Most people start prompting before they're clear on what they want. The result: hours iterating toward a vague target. Start with intent instead.
Document Decisions or Repeat Them
Every undocumented decision will be made again. Someone will face the same problem, not know you already solved it, and solve it differently.
Why Your Sprint Velocity Metric Is Lying to You
Velocity measures output. AI makes output unlimited. Your velocity graph means nothing anymore.
Context Is the New Code
When AI writes the code, the human's job is providing context. Context quality determines output quality. Context is the new skill.
Your Prompts Are Worth More Than Your Code
Code can be regenerated. Prompts encode the thinking that produces good code. Protect your prompts like the intellectual property they are.
The Bottleneck Moved. Your Process Didn't.
Writing code was the bottleneck. AI removed it. Now context retention is the bottleneck. But most teams are still optimizing for the old constraint.
Stop Calling It 'AI-Assisted' Development
AI-assisted implies AI is the helper. That's backwards. When AI writes most of the code, the human is the assistant. Time to update our vocabulary.