From the coach's corner.
Field notes on engineering leadership, team systems, and the shift toward AI-assisted development.
Should We Build This Has No Test Suite
AI can plan, build, test, and review software. None of those capabilities can prove that the objective deserved the investment.
Good AI Management Is Just Good Management
Agent loops and spec-driven development give AI workers what good managers give junior developers: the right context, delivered at the right time, inside clear boundaries.
DeepSeek Did Not Make Local AI Inevitable
Open weights made cheaper AI possible. They did not make hybrid AI easy. The missing product is the routing and operations layer that lets an ordinary enterprise use more than one model safely.
One User Can Spend Your AI Budget
The moment one employee can consume half a team's AI allocation in a day, AI stops being a productivity subscription and becomes infrastructure that needs governance.
What AI Companies Can Learn From the Auto Industry
Frontier labs do not need one model for every job. They need a product ladder that gives customers Toyota economics, Porsche capability, and Koenigsegg performance when the work earns it.
The Prediction Is Already Becoming Testable
Eighteen days after I predicted Anthropic would be the first major frontier-model provider to fail, the mechanism behind that prediction has started to become testable.
Tech Debt Has Gravity
Technical debt does not just slow teams down. At enough mass, it becomes gravity. Escaping it requires deliberate energy, protected capacity, and leadership willing to spend effort climbing instead of pretending every sprint is forward motion.
Spartan Simplicity: Carry Less
Every platform, pattern, library, and tool becomes something the team has to carry. Spartan simplicity is the discipline of keeping only what helps the team do the work right.
QA Belongs in the Loop
QA is not a final inspection step. QA helps the team orient, shorten feedback loops, and understand what correct means while the work is still cheap to change.
Boundaries Preserve Optionality
Good architecture is not about adding layers for their own sake. It is about preserving future options by putting decisions where they belong.
Taste Is Fast (and Earned) Orientation
Taste in software is not magic. It is fast orientation, and it only becomes useful when it can be examined, explained, and turned into judgment other people can use.
Your Team Is Fast. Can It Turn?
A top-fuel dragster is faster than a Ferrari until the road turns. Engineering teams make the same mistake when they optimize for feature output and lose the ability to maneuver.
A Fighter Pilot Is Hiding in Your Engineering Practices
Scrum, CI/CD, postmortems, and now agent loops all share one skeleton. A fighter pilot most engineers have never heard of sharpened it, and the part everyone keeps dropping is the part that matters.
The Loop Is the Easy Part
Everyone is hyping agent loops. The loop was never the hard part. A fighter pilot figured that out half a century ago, long before the rest of us typed a prompt.
The Mainframe Era of AI Is Ending
AI began in centralized data centers, but hardware, local models, and enterprise sovereignty are starting to move inference closer to the user.
Constantia: Principles Under Pressure
Standards matter most when following them feels unnecessary. Constantia is the discipline to preserve the controls that protect the team, even when the work is already good.
Virtus: Courage as Managerial Action
Courage in engineering leadership is not bravado. It is saying what is true, advocating for what is right, and accepting the consequences of doing so.
Anthropic Will Be the First Major AI Company to Fail
Anthropic leads the business AI coding market. I predict that its lack of control over compute will also make it the first frontier-model provider to fall.
Results Are the Only Thing That Matters
Clean code matters because results matter. Working software deserves respect, but respect is not immunity from change.
The Disciplined Codebase
Healthy codebases are not built by chasing what feels exciting. They are built through restraint, standards, boring consistency, and doing the necessary work in the right order.
Gravitas: Be the Calm
When pressure hits, the engineering leader's job is not just to avoid panic. The job is to project enough calm that the team can think, diagnose, and move.
Disciplina: Standards Beat Preference
A healthy codebase cannot depend on every engineer carrying a private version of good. Disciplina turns taste into shared standards the team can actually follow.
Pietas: Duty Is Not Always Gentle (Or Easy)
A manager has a duty to the struggling employee. That duty does not erase the duty to the team, the business, the customers, and everyone else absorbing the cost.
Roman Virtues for Engineering Leaders
Engineering leadership is tested under pressure. The old Roman virtues give us a useful language for the practical behaviors leaders need when the system gets hard.
You're Accountable for the Team. You're Not in Charge of It.
Tech leads are accountable for team outcomes they can influence, but cannot command. That is the job.
Effectiveness = Management × Contribution²
AI is collapsing the timeline on strategic initiatives. Work that used to take months of mapping and planning now takes days. That collapse changes the math of who should be building.
The Stoic Engineering Leader
You inherited the codebase you inherited. Leadership starts when you stop being offended by reality and start improving what is within your practical grasp.
The Harness Wars Have Started. We've Seen This Before.
Claude has already won. Copilot is dead in the water. Cursor is Elon's fantasy play. Every one of those takes is pontification dressed in the robes of an oracle.
Stop Reading AI Code. Score It.
The question was never read or measure. It was human or agent. The reviewer does not have to be you.
I Scored Four Codebases. The Humans Lost.
I scored four codebases against the same rubric. The two that failed were 100% human-written. The two that nailed it were 99% AI-written. Quality is not a human trait.
How to Set Agentic Coding Standards Across Multiple Teams
One dev uses Claude, another uses Copilot, a third uses Cursor. They're all generating code in your codebase. Without shared standards, you don't have standards.
Your Org Needs an Internal AI Skills Marketplace
AI skills are distributed software with privileged access. Treat them like part of your supply chain, not random files developers install from strangers.
Your AI Instructions File Should Be a Router, Not a Novel
Most teams dump everything into one massive AI instructions file and wonder why their agents ignore half of it. The fix is architecture, not more words.
Vibe Shipping Is the Real Problem
The generation method isn't the crisis. Giving up intentional control over what ships is.
The Art of Software Development
Good engineering strategy makes brute force unnecessary. Five lessons from Sun Tzu show how roadmaps, measurement, terrain, constraints, and systems turn struggling teams into predictable ones.
Software Development Has Always Been Moving in One Direction
From assembly to compilers to frameworks to AI: software development keeps moving toward higher abstraction, faster feedback, and clearer intent.
Give Your AI Agent a Map of Your Codebase (For Free, Locally)
Every AI coding session starts with your agent scanning the codebase to figure out what's going on. A code map eliminates that cold start entirely.
The Three-Agent Playbook for Legacy Code Modernization
Legacy rewrites fail because business rules buried in old code get lost in translation. A three-agent pipeline extracts that knowledge before anything changes.
The Jordan-Karpathy Effect
AI amplifies the foundation you bring to it. Senior engineers get leverage because they have judgment, standards, and enough context to direct the tool.
Vibe Coding Is Not a Strategy
AI can write code quickly, but engineers still own intent, architecture, standards, review, and the decision to ship.
Good Code Isn't Taste. It's Measurable.
Calling code quality 'taste' sounds sophisticated. It's actually the reason teams can't teach it, can't enforce it, and can't get AI to meet it.
AI Doesn't Write Spaghetti Code. You Do.
AI can produce spaghetti code. It usually does so when the organization gives it no standards, no local context, and no meaningful way to check the work.
Stop Telling Kids to Major in Computer Science
AI writes the code now. The skill that matters is understanding the business problem. For most software careers, a business degree with a CS minor wins.
Your Internal NuGet Packages Are an AI Blind Spot
AI coding tools know every public package cold. Yours? Brand new to them. Here's what happens when the AI guesses, and how to fix it.
Your AI Can Write Code. It Still Needs Stories.
AI can generate features from a prompt. That's exactly why you need stories more than ever. Without them, you ship generic output and call it productivity.
The AI-Powered Requirements Pipeline That Makes Planning Faster
Four AI skills chained together that help a product owner turn feature ideas into developer-ready stories without starting from a blank page.
In Celebration of the Product Owner
The product owner is the most undervalued role in software. Every team that skips it pays the price in rework, missed sprints, and developers building the wrong thing.
All Your (Code)Bases Belong to Us
AI companies are scraping public repos and shipping community innovations as features. If your code enhances an agentic platform, think twice before going public.
You're Reading DORA Backwards
DORA metrics tell you what elite teams look like. They don't tell you how to become one. Most engineering leaders get this backwards. And it's costing them.
Developers on Islands
When each developer owns their slice of the codebase and nobody else knows how it works, your team's velocity number is a fiction. Here's what it costs.
Engineering Leaders Have the Advantage in the Age of AI
Defining outcomes, reviewing output, managing feedback loops: the skills that make a great engineering leader are exactly what makes someone effective with AI.
Splitting Stories: The Skill That Makes or Breaks Sprint Velocity
One of the surest ways to kill a team's productivity is to saddle it with large stories. The tricky part is they don't always look large on the surface.
Tech Debt Is a Choice, Not a Failure
Technical debt can be a rational business choice. It becomes neglect when the cost disappears from view and the team keeps paying interest without reducing the principal.
Your AI Code Quality Problem Is Actually a Standards Problem
Developers complaining about AI-generated slop are diagnosing the wrong problem. The code isn't bad because of AI. It's bad because of you.
Your Team Is Doing Scrum. Does It Understand Scrum?
Most teams that 'do Scrum' have learned the ceremonies but missed the point. The ceremonies are not the methodology. They're just the surface.
Skills You Need as a Dev Manager: Product Owner
A development manager cannot lead delivery without understanding product ownership. Someone has to turn vision into sequence, protect priorities, and define work small enough to ship.
Think about RIOTS
CRUD describes what happens to stored records. RIOTS helps developers trace how data moves and changes between those operations.
High Performers vs Good Managers: Lessons from the Hardwood
The best contributor succeeds through personal output. The manager succeeds by creating the conditions for other people to produce excellent work.
MVP in Personal Projects
The hardest discipline in personal projects is building the smallest thing that proves your idea works, not the grand vision you have in your head.
Managing vs Orchestration and Enablement for Software Development Teams
A development manager is accountable for the performance, but does not produce it alone. The job is to understand the product, draw out each developer's strengths, and shape their work toward the result users need.