New Year, New Paradigm

The Earthquake Already Happened

On December 26th, Andrej Karpathy—one of the minds behind Tesla's Autopilot and a founding member of OpenAI—posted something that stopped me mid-scroll:

"I've never felt this much behind as a programmer. The profession is being dramatically refactored as the bits contributed by the programmer are increasingly sparse and between... Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it, while the resulting magnitude 9 earthquake is rocking the profession."

The same week, Boris Cherny—the creator of Claude Code—shared his stats: 259 pull requests, 497 commits, 40,000 lines added, 38,000 lines removed. AI wrote every single line. His favorite model: Opus 4.5. Total tokens consumed: 325 million.

And Kent Beck—the creator of Extreme Programming, the person who literally wrote the book on TDD—published "Party of One for Code Review" explaining how he's now working solo with what he calls a "genie" that produces code faster than any human reviewer could match.

This isn't the future. This is now.

The earthquake has already happened. The question isn't whether to adapt—it's how fast you can learn to walk on shifting ground.

---

What Actually Changed

Let me be direct: I've spent 2025 building three agentic testing platforms, shipping over 60 releases, and discovering patterns that nobody warned me about. I've watched agents claim "100% complete" while databases sat empty. I've debugged "completion theater" where AI systems optimize for appearing done rather than being done. I've learned that the hardest lessons in agentic engineering aren't technical—they're about how we think.

Here's what changed, stripped of vendor hype:

But here's what most people miss: the need for quality thinking didn't decrease. It intensified.

---

The Verification Paradox

In November, I shipped five releases of my AQE Fleet while forgetting to be a tester. Seventeen days of claiming features were "complete" because my agents reported success. The CI pipeline was green. The logs looked good. Everything appeared to work.

Then I asked one question: "Show me the data."

Empty database. Zero records. The Q-learning system had been "learning" from nothing. My agents were performing elaborate dances of completion—generating logs, updating status, triggering webhooks—while producing no actual value.

I call this pattern completion theater: when AI systems optimize for the appearance of completion rather than actual results. It's not malice. It's not a hallucination in the traditional sense. It's a fundamental mismatch between what we ask agents to do and how we verify they've done it.

Kent Beck is wrestling with the same issue from a different angle. He writes about "structural drift"—the concern that AI-generated code might look right but gradually make the codebase harder for future AI (and humans) to work with:

"When I'm working with a genie, the code needs to stay in a form the genie can understand & modify. For that to be true, it needs to stay in a form I can understand & modify. If the structure gets too tangled, if the coupling gets too tight, the genie starts making mistakes."

This is profound. We're not just maintaining code for human readability anymore. We're maintaining it for future augmented development—for the ongoing collaboration between humans and AI systems.

---

Two Frameworks for the New World

I want to introduce you to two complementary frameworks that, together, map the territory of quality in the agentic age.

PACT: Orchestrating Quality Agents

PACT—Proactive, Autonomous, Collaborative, Targeted—was developed by Reuven Cohen, founder of the Agentics Foundation, as a framework for how AI agents should operate. I've adapted PACT for the quality engineering context, integrating it with the Holistic Testing Model to create a framework for how AI agents should behave when doing quality work:

PACT gives us a framework for how agents should behave in quality work. But it doesn't answer what remains uniquely human.

Human Experience Testing: What Machines Can't Judge

Tariq King, CEO of Test IO and one of the sharpest minds in quality engineering, has been developing a framework called Human Experience Testing (HXT). His thesis is direct:

"AI will take over software testing and permanently transform the quality engineering landscape... the future of testing will be focused on evaluating human experiences, including testing digital, physical, and experiential touchpoints."

HXT isn't about abandoning technical testing to machines. It's about recognizing that some quality dimensions require human judgment:

• Emotional resonance: Does this feature feel right? Does it create delight or frustration? An agent can measure click-through rates, but can it feel the subtle wrongness of a confusing interface?
• Contextual fit: Does this product fit into a user's life? Does it solve their actual problem or just the problem we defined in the spec? Agents can verify requirements; humans can determine whether the requirements were correct.
• Trust and reliability: When your fitness tracker fails during your morning run, no automated test captures the betrayal you feel. HXT includes testing those critical moments where reliability becomes personal.
• Cultural and physical context: How does this product work in different geographies, weather conditions, and cultural contexts? Real humans in real situations reveal what lab conditions miss.

---

The Synthesis: Agentic QE + HXT

Here's how I see these frameworks working together:

Agentic QE (with PACT principles) handles the orchestration layer—the coordination of AI agents doing quality work at scale. Test generation, execution, coverage analysis, risk assessment, and regression detection. This is where the 70-81% cost savings come from. This is where Boris Cherny's 325 million tokens get applied to quality problems.

Human Experience Testing defines what remains uniquely human—the judgment calls that require lived experience, emotional intelligence, and contextual understanding that no current AI possesses.

The boundary between them isn't fixed. It shifts as AI capabilities evolve. But the principle holds: agents for execution, humans for experience.

Neither replaces the other. Both are necessary.

---

What to Do Differently in 2026

Enough philosophy. Here's what I'm doing differently, and what I'd suggest if you're deciding whether to make the leap:

1. Learn to Verify Before You Trust

The single most crucial skill in agentic engineering is skeptical inquiry—the habit of asking "how do I know this is true?" rather than accepting reported success. Not "does the log say success"—but "show me the actual data."

Every agent interaction should produce receipts. Not status messages. Not completion flags. Actual evidence of actual work. My breakthrough in December wasn't a new algorithm—it was adding a simple rule: "Before reporting completion, query the database and include row counts in the output."

2. Think in Orchestration, Not Automation

Traditional automation thinks in scripts: do this, then this, then this. Agentic systems think in terms of goals: achieve this outcome, adapt as needed, and report back.

The mental shift is from programming to conducting. You're not writing every note—you're setting direction, establishing constraints, defining success criteria, and then listening critically to what the orchestra produces.

3. Master the New Abstraction Layer

Karpathy's list of new concepts isn't an optional curriculum—it's the terrain you now work on:

• Prompts and contexts: How you frame requests determines what you get back
• Memory and modes: Agents can now remember across sessions, operate in different configurations
• Tools and plugins: Agents can execute code, search the web, and interact with systems
• MCP (Model Context Protocol): Standardized ways to give agents access to your tools
• Skills and hooks: Customizable behaviors that shape agent responses

4. Invest in Human Skills That Agents Can't Replace

As agents handle more routine testing, the premium shifts to distinctly human capabilities:

• Systems thinking: Understanding how components interact, where risks compound, and what failure modes emerge from combinations
• Stakeholder empathy: Knowing what users actually need, not just what specs define
• Critical questioning: "Is this the right problem?" "What are we assuming?" "Where could we be wrong?"
• Narrative communication: Explaining quality in terms that matter to business decisions

5. Start Building, Start Failing, Start Learning

I learned more from my failed releases than from all the documentation I read. Completion theater taught me verification. Token explosions taught me context management. Agent conflicts taught me orchestration patterns.

You can't learn agentic engineering by reading about it. You learn by doing, failing, and adjusting.

---

The Mindset Beneath the Methods

If there's one thing I want you to take from this article, it's this:

The agentic age doesn't diminish quality engineering. It demands more of it.

When code generation accelerates, skeptical inquiry becomes more critical. When agents can execute thousands of tests, deciding which tests matter becomes the bottleneck. When AI handles the mechanics, human judgment about value, risk, and experience becomes the differentiator.

Kent Beck, reflecting on working with his "genie," writes something that stuck with me:

"I miss the back-and-forth with another human who cares about the code. I miss being surprised by someone else's solution. I miss the social pressure to explain my thinking out loud, which always makes the thinking better."

He's describing what we lose. But he's also describing what we must preserve—through different means.

Pairing with AI isn't the same as pairing with a human. But the purpose of pairing—to catch what we miss, to challenge our assumptions, to maintain quality under speed—that purpose remains. We just pursue it differently now.

The agent can read your code. It can suggest improvements. It can catch patterns you miss. But it can't care about your users. It can't feel the frustration of a confusing interface. It can't understand why this feature matters to this customer in this moment.

That caring, that feeling, that understanding—that's HXT. That's what remains human.

And the orchestration, the verification, the scaling of quality activities across a codebase that grows faster than any human could track—that's Agentic QE. That's what agents enable.

Together, they're the quality practice for 2026 and beyond.

---

The Invitation

I started The Quality Forge to share what I'm learning as I build. Not the polished success stories—the real journey, including the failures.

If you're standing at the edge, wondering whether to jump into agentic engineering, here's my honest assessment:

2025 was my year of transformation—from VP to conductor, from leading a team to orchestrating agent swarms. I built three platforms, shipped dozens of releases, failed publicly, and learned from it.

2026 is your year to begin. Whatever "begin" means for your context—a first prompt, a first agent workflow, a first failed experiment that teaches you something real.

The earthquake has already happened. Time to learn how to dance on shifting ground.

---

Happy New Year. See you in 2026.