I’ve spent the last few months neck-deep in AI agents, watching them crank out pull requests, refactor services, and even debate trade-offs in real time. And yeah, the velocity is insane.
But every time the hype machine screams “AGI tomorrow!” I remember the same truth we engineers have always known: tools are tools. LLMs are the most powerful teachable models we’ve ever had — but they are still just models.
This isn’t another fluffy “AI will replace developers” piece. This is the post-Context-Anchoring reality check, written by someone who actually ships production systems in 2026. Martin Fowler dropped his piece on Context Anchoring two weeks ago and it crystallized everything I’ve been seeing in the trenches.
So let’s cut the noise.
What AI Can Do — When You Stop Treating It Like Magic
LLMs excel at pattern matching at superhuman scale. Feed them the right context, and they become the best junior-to-mid-level pair programmer you’ve ever had.
- Production-grade code generation: From clear, anchored specifications.
- Trade-off exploration: They can surface implementation paths and edge cases in seconds.
- Codebase hygiene: Refactoring messy code, writing tests, and catching architectural smells.
- Documentation synthesis: Turning scattered decisions into living, queryable artifacts.
- 3-5x Velocity: Measurable acceleration when the codebase is clean and the context is engineered.
I’ve watched agents merge thousands of zero-human-touch PRs (shoutout to Stripe’s Minions). That’s not hype — that’s measurable velocity.
The Pro Tip: These capabilities only appear when you treat the LLM as a teachable model, not an oracle. Clean Architecture, DDD bounded contexts, and Context Anchoring turn probabilistic noise into reliable output.
What AI Can’t Do — And Never Will
This is the part the hype skips. LLMs have hard, fundamental limits that no amount of scaling or “agentic workflows” will erase.
1. Genuine First-Principles Reasoning
It’s a statistical pattern matcher. It can mimic understanding, but it has no internal world model. It can implement a retry queue because it’s seen a thousand of them; it cannot invent a genuinely novel resilience pattern for a domain it has never encountered without human guidance.
2. Durable Context Without External Memory
Fowler nailed it: conversations are ephemeral. The “Lost in the Middle” effect is real. Without a living feature document — decisions, rejected alternatives, constraints — the model will happily re-propose a rejected idea three sessions later.
3. Architectural Sovereignty
It can propose options, but it cannot weigh business risk, regulatory reality, or team cognitive load. Probabilistic models make probabilistic mistakes. You build deterministic pipelines around them (Agent Reliability Engineering). The architect remains the final validator.
4. Accountability
When the system blows up at 3 a.m., the model doesn’t get paged. You do. Full stop.
5. Deciding What Should Be Built
It can implement. It cannot decide the problem worth solving. That is, and will remain, human territory.
Best Practices That Actually Work
If you want LLMs to deliver consistently, follow these rules:
- Anchor everything. Feature documents > endless chat history. Make decisions external, versioned, and queryable.
- Apply old-school engineering ruthlessly. Bounded contexts and Hexagonal Architecture make code self-documenting. Agents need 60-70% less context to do their job.
- Build deterministic guardrails. Use observability and automated validation for every probabilistic agent.
- Document the why religiously. ADRs (Architecture Decision Records) are the single source of truth that stops hallucinations in their tracks.
- The "Intern" Rule: Treat the model like a brilliant but forgetful intern. Give it explicit constraints and rejection lists.
The Engineer’s New Baseline
The bar hasn’t been lowered — it’s been reset. Syntax is now table stakes. What matters today is architectural judgment, context engineering, and the ability to turn probabilistic output into deterministic systems.
LLMs are essential and teachable. When paired with discipline, they let us ship faster than ever. But they will never replace the human who owns the “why,” anchors the context, and carries the pager.
That’s still us.
Stay building.
Pedro Savelis (@psavelis) Staff Software Engineer | Sovereign Platform Architect | Post-Quantum + DePIN Systems Builder
Drop your biggest “aha” moment from Context Anchoring or Agent Reliability Engineering below. I read every reply. Let’s keep the conversation anchored.
Top comments (0)