My 2026 AI Bets (A Time Capsule)

This will be a longer post covering how I’m thinking about AI, engineering, and what actually matters going into the new year.

If you want the quick version, here’s what I’m betting on for 2026:

1. Agentic loops > one-shot prompts — Multi-step, tool-using, self-correcting loops become the default way of working.
2. AI-native outcomes — The gap between “replaces workflows” and “adds features” is a valuation chasm.
3. The chasm becomes obvious — Superstar ICs with custom workflows vs everyone else. Companies that raise the floor win.
4. AI-navigable systems — Docs, tooling, and environments that let agents self-serve. If they can’t, you’re the bottleneck.
5. Org math changes — Fewer handoffs, smaller execution pods, different risk model.
6. Build vs buy flips — Internal tools become cheap to build; maintenance and evals become the real cost.
7. Services boom — “Agentification” consultancies will clean up, especially in the mid-market.

In late August, I published “I Managed a Swarm of 20 AI Agents for a Week—Here Are the 8 Rules I Learned” and “How to Use Claude Code Subagents to Parallelize Development”. Both went viral on Hacker News.

If I scroll on X now, every other post is about running parallel agents for 24 hours straight, shipping entire products in a weekend, orchestrating swarms. It’s old news. The specific techniques I wrote about—some aren’t even how people do things now. Claude Skills, better MCPs, new patterns that didn’t exist when I hit publish.

Three months and already outdated. That’s how fast this moves.

I knew I’d discovered something when I wrote those posts. I was right, and I was a little ahead of the curve. But the whole industry was right behind me. 2025 was the year we all figured out how this stuff works.

Since ringing in the new year, I’ve been thinking about how 2026 is going to play out. This is somewhere between predictions and priorities—what I think will happen, what I’m betting on, and a bit of a time capsule.

The Autonomous Loop Changed How I Work

For me, the shift happened in August with Claude Code.

I gave it browser access and the right instructions, and watched it build things in an autonomous loop: build → test → validate → fix → complete. When it worked, I found myself just waiting for it to write code. So I started spinning up multiple terminals—2, 3, 4 at a time. Implementation in some, technical planning in others. Sub-agents investigating different scenarios in parallel, delivering comprehensive plans in minutes.

When I saw that—parallel execution, screenshot interpretation, self-debugging—I knew the job had fundamentally changed.

Using AI Tools Is Table Stakes; Building Agentic Systems Is the Edge

Using Cursor or Windsurf or Codex is the bare minimum now. You should be doing that.

What makes something “agentic”? An agent can be given a task and iterate using its tools until done. It’s not one-shot. It’s multi-step, with tool calls, with the ability to check its own work. Think ChatGPT versus deep research mode—one gives you an answer, the other understands your question, loads webpages, synthesizes, and delivers a comprehensive result. That’s agentic.

The teams that win will figure out how to apply agentic design: building internal tools that leverage agents, automating manual workflows. The cost of building has collapsed—things you’d never build before are now afternoon projects.

Companies with organizational debt have a huge opportunity here. The teams that invest in “agentifying” their old-school workflows will automate away the toil. Humans do the work that humans should do. Everything else gets automated. Service gets faster, higher quality, more repeatable.

Products That Replace Work Command Higher Valuations Than Those That Assist

VCs are sorting companies by their relationship to AI, and markets are pricing AI-native outcomes at a significant premium relative to AI-enhanced SaaS.

Per Bessemer’s State of AI and their Cloud 100 benchmarks, AI-native applications—what they call “systems of action”—command materially higher multiples than traditional SaaS with AI features bolted on.

The difference comes down to two things:

1. Revenue per employee. AI-native companies start small and stay lean. One person delivers dramatically more value. Larger companies take longer to either grow revenue or shrink headcount to get those ratios.
2. Complete outcomes vs partial assistance. Here’s the test:

Can your product do what a customer would pay $50k/year for a human—or a business—to do?

It’s not just about automating individual jobs. Think about entire B2B relationships that had humans behind the scenes: marketing agencies, consulting firms, service providers. If your product can deliver that complete outcome autonomously, you’re AI-native. If it helps but they still need someone—you’re AI-enhanced.

Adding a “summarize this” button? AI-enhanced. Building complete workflow automation, AI-generated video at scale, dynamic AI interviews? AI-native. These things couldn’t exist two years ago—and they replace work, not just assist with it.

One Person Who Ships Beats a Coordinated Team

This is why the builder archetype matters more than ever.

Every human you coordinate with is a tax: conversations, handoffs, context switching, waiting. When one person can talk to stakeholders, conceptualize the solution, and build it—no network hops, no fragmentation. Every conversation benefits them directly. They understand the problem. They ship the solution.

What about specialists? There’s still value in deep systems-architect thinking—people who understand nuanced domain problems and have built at scale. But the moat is shifting. Models are becoming broadly competent across domains, and with the right access (docs, repos, tools) they can outpace humans on retrieval and synthesis.

Specialists still matter—but the moat shifts from what you know to what you can validate and operationalize. The specialist’s value becomes framing the right problems, validating nuanced outputs, and handling edge cases that models struggle with.

The Chasm Between Adopters and Laggards Will Become Undeniable

2026 is going to be the year the gap becomes obvious.

At the IC level, you’ll see a massive drift between AI-native superstars and everyone else. The superstars won’t just use off-the-shelf tooling—they’ll have their own workflows. Custom MCPs wired together, personal orchestration patterns, tooling they bring company to company. I’ve seen people online talk about “the next 10x engineer” having their own amazing workflows as a portable asset. I think that’s right. Orchestrating agents effectively is a skill in itself, and the people who develop it will be in a different league.

Companies will be slower to act on this than individuals. The forward-thinking ones will figure it out. They’ll invest in raising the floor—building workflows and giving them to their teams, making it where people have no choice but to succeed. When the tooling is that good and that embedded, everyone gets lifted.

The alternative is letting the floor stay low by default and hoping the ceiling is high enough. Some individuals will figure it out on their own. Most won’t. The companies that invest in the floor—curated workflows, opinionated tooling, embedded best practices—are going to dramatically outperform those that just tell their teams “go use AI.”

If Agents Can’t Answer Their Own Questions, You’re the Bottleneck

If you have a large codebase across multiple repos, here’s the question: Can an agent answer its own questions without waiting for a human?

This is what I mean by “AI-navigable.” Here’s the checklist:

• Single source of architectural truth — System map, ownership, conventions documented where agents can access them
• Toolable interfaces — MCP tools for common queries and actions (Devin’s deep wiki, internal knowledge bases)
• Ephemeral environments + test harness — Agent can create a branch, spin up a real environment, and test against it
• Guardrails — Permissions, audit logs, rollout controls
• Eval loop — Regressions and quality checks baked in, not bolted on

Anything that removes the human from answering questions or validating work is valuable. The curated skills, commands, progressive disclosure—as the agent navigates, it finds what it needs and course-corrects.

Bus Factor Improves—But Only If You Invest in Navigability

AI changes the bus factor calculation—but only if you invest in navigability.

Old world: Losing a key engineer means weeks of ramp-up. Institutional knowledge is lost.

New world: An agent can explore, debug, and operate from zero context quickly. It can handle on-call incidents, auto-fix issues, review code. But this only works if your systems are instrumented, documented, and toolable. Bus factor improves dramatically if you make the investment. It doesn’t magically disappear.

Execution Pods Shrink; Support Systems Grow

Here’s my challenge to any engineering team: Can you deliver the same value as your current scrum team with a significantly smaller execution pod?

The math has changed. Fewer handoffs, fewer meetings, each hour more effective. But this doesn’t mean everything shrinks.

Execution pods shrink — Smaller teams doing the building, less coordination overhead.

Support systems grow — More investment in platform primitives: evals, observability, release safety, permissions, audit logs, test harnesses. The infrastructure that makes small teams safe and effective.

This is the counter-model people miss. You’re not just cutting headcount—you’re reallocating toward the systems that let small teams operate with confidence.

Caveat: Regulated industries—healthcare, finance, sensitive data—will move slower. Different playbook, more constraints.

Boutique “Agentification” Consultancies Will Clean Up

There’s going to be a huge opportunity for consultants.

Big companies like Accenture are already selling AI strategy to enterprises. But mid-sized businesses can’t afford that. Boutique agencies, specialized consultancies, individual freelancers who can say “I will make your org AI-native”—they’re going to clean up.

Think about WordPress retainers: plugin updates, security patches, basic maintenance. Thousands of dollars a month for straightforward work.

Now imagine retainers for agentic systems. More complex, more valuable, and virtually every business needs it—not just ones with websites. Higher premiums, larger addressable market.

Leaders: Set Real Budgets, Remove Friction, and Learn It Yourself

Set real budgets. Stop worrying about $20/month Cursor subscriptions or $200/month Claude Code Max. That’s the wrong frame. Think hundreds per week, thousands per month per engineer. The ROI is there.

Remove friction aggressively. Things move too fast. Get out of your team’s way. Remove barriers, encourage experimentation.

Learn it yourself. Non-negotiable. If you’ve never built anything with agents, never felt that moment where the loop just works—you won’t see the solutions that others see. You’ll get outpaced by leaders who do.

I see directors at FAANG companies doing this. CTOs, managers, ICs—people all up and down the spectrum building with AI themselves.

If this feels overhyped, the fastest way to calibrate is to run one real workflow end-to-end yourself. Pick a task, give an agent the right context, and watch what happens.

The Trust Problem Could Slow Everything Down

Maybe there’s something I’m not seeing. Maybe orchestration leapfrogs agents entirely, or something new drops that makes all of this obsolete.

The counter-force I’m watching most closely: governance, safety, and enterprise constraints. Data privacy, auditability, permissioning, continuous evaluation. I nod to regulated industries above, but it’s broader than that.

The winners won’t just build agents—they’ll build trusted agents. Systems with guardrails, evals, audit trails, and rollback mechanisms. Bessemer emphasizes continuous evaluation as mission-critical for enterprises, and I think they’re right.

If the trust problem proves harder than the capability problem, this all moves slower.

But for engineering specifically? I’m confident. Agents are the paradigm shift. Teams that build agentic systems, make their codebases AI-navigable, embrace the builder archetype, and reallocate toward support infrastructure are going to dramatically outperform those that don’t.

That’s how I’m thinking about 2026. Part prediction, part priorities, part time capsule.

Let’s see how it ages.