Newsletter #104
Enjoy Newsletter #104.
Designing the AI-native engineering organization
In a panel at the DX Annual conference, engineering leaders from Microsoft, 1Password, and Atlassian shared how AI is reshaping the software development lifecycle (SDLC). Previously, roughly 80% of engineering time went into execution and operations, but in the highest-performing teams that ratio is flipping: as AI compresses code generation and routine execution, planning and verification now take up the bulk of the time, because that is where human judgment matters most. The speakers advised against handing verification or security over to AI just yet.
Notably, none of the companies redrew their org charts; what changed is how teams work internally. Atlassian forms 3–4 person pods for greenfield projects, Microsoft uses small v-teams running on eight-week cycles for rapid learning, and 1Password shortened its planning horizon from 12–18 months down to a single quarter. None of the three mandated AI usage; instead, they invested in training, amplified internal “champions,” and shared concrete success stories. Token spend is managed as rigorously as cloud infrastructure costs, with 1Password building internal tooling to map spend by repo and project. The archetype of the future engineer is a “maker” with broad generalist knowledge, strong product intuition, and the agency to make decisions. Non-engineers like designers and customer experience staff are now submitting pull requests too, though that is only safe when backed by a solid test suite and deployment verification pipeline.
10 Lessons for Agentic Coding
Drew Breunig distills ten lessons for developers working with AI agents like Claude Code, Codex, or Pi around a central question: what should you do when code becomes cheap? Because writing code surfaces decisions that a spec never anticipated, he advises implementing to learn and not hesitating to throw code away and rebuild multiple times to test bold ideas. Pair that with end-to-end tests that measure product behavior rather than implementation details, leaving you free to rewrite the underlying code. Neither tests nor code capture why something was built a certain way, so keep intent alongside the codebase and evolve the spec in tandem with development rather than freezing it up front.
When the easy parts are handled quickly by AI, real value shifts to the hard parts: intuitive design, performance, security, fault tolerance, and system architecture. Automate all the easy work to free up time for the hard problems, and cultivate your own “taste” — because when code is generated faster than external feedback can arrive, your domain and user understanding become the only feedback loop fast enough to keep pace. AI agents also amplify experience: engineers with deep technical mastery know the right terminology, how to frame problems, and the right level of specificity, saving countless iterations. The final lesson is a reminder: code is cheap, but maintenance, support, and security are not.
Just Fucking Use Go
In an intentionally blunt polemic, Blain Smith argues that Go has been sitting there for over a decade waiting for developers to stop overcomplicating backend development. Go’s boredom is by design: no decorators, no macros, no metaclasses — just structs, functions, interfaces, goroutines, and channels. Because of that, a newly hired junior developer can read code written two years ago by someone who already left, and gofmt enforces a single formatting style, ending all style debates. The standard library is the framework: net/http, database/sql, encoding/json, and html/template paired with embed are enough to build a complete database-backed web app with zero third-party dependencies; io.Reader/io.Writer and context.Context make every component snap together cleanly and propagate cancellation end to end. Goroutines cost only about 2KB at startup, and channels handle synchronization.
The biggest advantage is operational: go build produces a single static binary that you can scp to a server and restart with systemd — no Dockerfile, Kubernetes, or service mesh required. Dependency management fits neatly into go.mod and go.sum, while testing, race detection, benchmarking, and profiling ship built-in with the toolchain. The author criticizes Rails, Django, Express, and Next.js for elaborate deployment rituals and constantly shifting conventions, advocating instead for a monolith consisting of one Go binary and one PostgreSQL instance rather than chasing microservices. Even if err != nil error handling is praised as a feature, because it forces you to decide how to handle failures at every call site where something can go wrong.
Symptoms of Bad Software Design
Marcos F. Lobo outlines four symptoms of poor software design along with how to fix them. Rigidity is when a small change in one module triggers a cascade of changes across dependent modules, turning a two-day estimate into two weeks; the root cause is usually tight coupling. For example, an order-processing class with a giant switch statement calculating shipping rates for every carrier can be refactored using the Strategy Pattern (Open/Closed Principle) so each carrier has its own class and adding a new one requires no edits to existing code. Fragility is when fixing something in one place breaks an unrelated feature elsewhere — such as changing a date format in a global config Singleton and breaking the payroll module; the cure is encapsulation and interface segregation so each module only sees the configuration it actually needs.
Immobility appears when business logic is so entangled with UI, database, and framework code that extracting it for reuse takes more effort than rewriting it from scratch. The solution is layered architecture (Clean Architecture): isolate the core algorithm into a pure component that receives database access through an interface following the Dependency Inversion Principle. Viscosity is when doing the right thing is harder than hacking in a shortcut, whether due to software design or a sluggish development environment, pushing developers toward band-aid fixes. The remedy is automating and improving infrastructure and using tooling to cut boilerplate so the right path is nearly as fast as the wrong one. Recognizing these four symptoms is the first step toward incremental refactoring.
Claude Code is Not Making Your Product Better
Ethan Ding challenges the notion that AI coding agents are making products better, even as code output climbs. Commit-size charts show a K-shaped productivity split: senior engineers have seen a sharp jump in output since 2023, while junior engineers have largely flatlined or declined. Builders like dax (opencode), Karri Saarinen (Linear), and David Cramer (Sentry) all struggle to see faster product improvement from agents. The author argues that if Claude Code truly created a compounding advantage, Anthropic should have pulled far ahead of competitors after months of exclusive internal use, yet the later-arriving Codex competes neck and neck — meaning the bottleneck to product quality was never typing speed.
The best engineering cultures treat lines of code as a liability rather than an asset, because every line is surface area for bugs and accumulating complexity; tinychat even sets alerts when the codebase crosses a size threshold and celebrates deleting code. Linear achieved higher quality than Jira with a fraction of the engineering headcount because the difference comes from creative vision and restraint — deciding to build less — rather than token generation speed. In the author’s view, coding agents help products get from zero to “decent” faster and will make commodity software much cheaper, but they don’t help frontier teams build extraordinary products — leaving behind a pile of technical debt that someone will eventually have to clean up.
The Pulse: AI load breaks GitHub – why not other vendors?
Gergely Orosz analyzes GitHub’s recent string of severe outages. On April 23, a bug caused pull requests merged via merge queue using squash merge to produce corrupt commits whenever a merge group contained more than one PR, “losing” commits across 2,092 pull requests — violating the most fundamental data-integrity guarantee and forcing customers to recover manually. A wave of other incidents followed: an overloaded Elasticsearch cluster made pull requests and issues vanish from the UI for 6 hours, GitHub Actions suffered outages, and Wiz disclosed a critical RCE vulnerability. An unofficial third-party tracker recorded uptime around 86% (measured as time with no component reporting an incident), or “zero nines.” Mitchell Hashimoto, creator of Ghostty, announced he was leaving GitHub after 18 years because near-daily outages were blocking his work.
GitHub’s CTO blamed higher-than-forecast load from AI agents: traffic grew roughly 3.5x over two years, with most of the surge concentrated in recent months. GitHub only began planning a 10x capacity expansion in October 2025, months behind Google, and by February 2026 had to revise the target to 30x. At the same time, the company is migrating from its own data centers to Azure, making underlying flaws much more likely to surface as outages. Why, then, have Vercel, Linear, GitLab, and Bitbucket weathered similar AI traffic waves without buckling? Orosz argues that much of GitHub’s pain is self-inflicted: a heavily stateful architecture that is hard to scale horizontally, 18 years of technical debt, roughly 4,000 employees who have to coordinate, and an inability to break existing customer workflows.
You Need AI That Reduces Maintenance Costs
James Shore gets straight to the point: coding agents must reduce maintenance costs, and they must reduce them in proportion to the increase in code-writing speed. Every line of code carries an indefinite maintenance tail of bug fixes, cleanup, and dependency upgrades. Using a “wisdom of the crowd” estimate, he assumes each month of feature coding generates roughly 10 days of maintenance in the first year and 5 days in each subsequent year. Modeling this in a spreadsheet shows that after about two and a half years, a team spends more than half its time on maintenance, and after ten years it can barely build anything new — matching what he observes when consulting for late-stage startups.
Applying this to AI: if an agent doubles code output but produces code that is twice as hard to maintain, the productivity gain is wiped out in roughly five months, and long-term velocity ends up lower than without AI. Even if AI-generated code is just as maintainable as human-written code, the net benefit only lasts about 19 months. Worse, if a team later stops using agents due to high costs, the speed boost disappears while the maintenance burden of all that generated code stays behind — a form of “perpetual servitude.” Shore’s conclusion: maintenance cost must drop inversely with output — doubling output requires cutting maintenance cost in half. Teams should therefore invest at least as much effort into reducing maintenance costs as they do into chasing coding speed.
Cognitive Surrender
Addy Osmani introduces the concept of “cognitive surrender” from research by Steven Shaw and Gideon Nave (Wharton). It must be distinguished from “cognitive offloading”: offloading delegates the “how” to AI while you still evaluate the result yourself, whereas surrender happens when you stop forming your own answer and let the AI’s output become your output. Across three experiments with 1,372 participants, when AI gave a wrong answer, participants accepted the incorrect answer 73% of the time, and their confidence actually increased even though half the answers were deliberately rigged to be wrong. For developers, this shows up as approving a 600-line PR just because tests are green, letting an agent fix a bug without understanding the root cause, or letting an agent make architectural decisions.
Software engineers are uniquely vulnerable because generated code compiles and passes linters so it looks right on the surface, productivity metrics count merged PRs, and models always speak in an authoritative tone. Each act of surrender is a small loan that compounds into “comprehension debt” — the growing gap between the code that exists and the code humans actually understand. To push back, Osmani suggests forming your own expectations before looking at the output, reading diffs as if they were written by a junior dev, asking the model to critique itself, watching out for fatigue, keeping PRs small, and treating verification evidence as a mandatory condition for finishing a task. If code keeps shipping while your understanding of the system shrinks, you are accumulating comprehension debt.
Bonus
Images:

This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.
Comments