Everyone Should Build

TL;DR

• AI should write 100% of your code.
• Software engineering has a bright and exciting future.
• Build AI engineering strategy for your company.

Shift!

Confession

On March 10, 2025, Dario Amodei of Anthropic said, “there in three to six months, where AI is writing 90% of the code” (source), and I was skeptical.

Now, AI drafts effectively 100% of the implementation code I ship – meaning I rarely type code manually. I focus on: task definition, constraints, tests, reviews, and integrating changes into production safely. It is also the case for many top engineers (and not only engineers).

Typing code manually: never again, thanks.

With the next prediction – “We might be 6–12 months away from models doing most of what software engineers do end-to-end” – as evidence shows, this might be true as well.

We have so many actual datapoints about how effective AI-enabled engineering has become, that it’s impossible to ignore.

Company	Claim	Type	Source
Alan	283 pull requests from non-engineers shipped	Company case study	alan.com
METR	AI capability on long tasks doubles roughly every 7 months	Research finding	metr.org (March 2025)
Anthropic	Opus 4 / 4.5 matches or outperforms take-home eval constraints	Vendor benchmark	Anthropic Engineering (January 2026)
Anthropic	Opus 4.6 agent team built a 100,000-line C compiler capable of compiling the Linux kernel	Vendor demo / case study	Anthropic Engineering (February 2026)
Spotify	Best devs haven’t written code since Dec; shipped 50+ features in 2025	Media anecdote	TechCrunch (February 2026)

The shift is even bigger than when we moved from machine code to compilers!

See this picture – well – we don’t do this anymore!

If you have a good and well-defined task description – consider you have a solution.

But nothing speaks better than personal experience – just try it! Install Claude Code, Codex, Cursor – anything and build something!

Who Benefits Most

• Engineers: less time on repetitive implementation
• Prototypers/PM/Designers: faster idea-to-proof
• Operators who can steer and orchestrate agents

Core skill: ask clearly, instrument outputs, correct early.

Coding Agent

Why does it happen? It’s very easy to state this, but only few people understand the core of the reasoning: Agents.

What Is an Agent (Practical Definition)

Agent = LLM + Actions + Loop

• LLM: reasoning and planning
• Actions: tools, shell, APIs, MCP, skills
• Loop: iterative execution until goal or stop condition

If the actions include writing and running code, you can call it a coding agent.

What Is an Agent (Intuitive Definition)

Imagine a simple invoice process: step 1 -> step 2 -> step 3. It’s small, predictable, and mostly one-size-fits-all. An agent solution for this use case can be a generated list of actions:

But if any complications arise, the agent adapts: branching, adding steps, and iterating as needed.

For each input, the agent would realize exactly one unique instance of a simple business process, tailored to the specific input and circumstances. AKA: from “one size fits all” to “tailor-made”.

And what are the most successful agents out there? Coding. It’s way easier to verify code (running or not, tests passing or not, compiled or not, and whether software does what you want). Now imagine each agent might have its own agent and so on; this already exists and works really well: open example: K2.5 Agent Swarm, Claude example.

Future (Predictions)

So how does the future look and how to prepare yourself! Here are several of my predictions:

“Agent Tech Leads

Everyone becomes an agent tech lead – aka agent orchestrator.

This is the future of software engineering: we’ll see roles explicitly focused on agent orchestration, guardrails, and verification.

“Agent tech lead” job description here.

Rule of thumb: the product builder’s job shifts toward managing, coaching, and reviewing coding agents.

Make sure other agents are first class citizens of your product

Agent TAM > Human TAM

There is a limited number of potential customers for your business, but there are unlimited numbers of agentic “customers” that need to query data, trigger workflows, or purchase services via APIs.

You won’t build every agent. But you can become their provider for data, execution, identity, payments, service guarantees, etc. This is already happening.

Generative UI

Structure your product so the data layer is the moat. UI and presentation layer are going to be defined and written on demand and on the fly.

Generative UI at Google Research.

Self-Driving SaaS

Software that runs itself, set up a feedback loop process for your users and most of the contributions would be done automatically.

Self-Driving SaaS at Linear

Sandboxes as Infrastructure

Simple thesis:: 1x value -> 100x coding agents -> 100,000x sandbox executions.

If agents are writing code, you need safe places to run that code. The more efficient and secure your execution environment, the faster (and safer) your delivery.

Services:

1. Together AI Code: https://www.together.ai/code-sandbox
2. Modal Sandboxes: https://modal.com/docs/guide/sandboxes
3. Daytona: https://www.daytona.io/
4. E2B: https://e2b.dev/
5. Cloudflare Sandbox: https://developers.cloudflare.com/sandbox/

DIY building blocks:

1. Kubernetes (broad): https://github.com/kubernetes/kubernetes
2. Firecracker (microVM): https://github.com/firecracker-microvm/firecracker
3. Docker sandboxes: https://docs.docker.com/ai/sandboxes/

Strategy

As any business, you need to adapt and embrace this shift. My recommendation: build a strategy with three tiers.

Tier 1: Prototype + Vision

Make sure everyone uses AI coding for new work – prototyping, demos, POCs, visualization. Instead of writing long PRDs, build a demo that communicates intent.

• Tools: AI Studio, Lovable, Bolt
• Goal: communicate product intent quickly
• Output: clickable prototype + feedback
• Metric: # of ideas validated per week/month

Guardrail: keep Tier 1 work out of production by default.

Tier 2: More Impact

Demos & validations are good – but you need to move AI engineering to converge into the core product – start using tools for your team, make sure they have access to a good amount of tokens.

• Tools: Claude Code, Codex, Gemini CLI, Cursor
• Requires: terminal, git workflow, deployment basics
• Output: real features with review pipeline
• Metric: development productivity (cycle time, PR throughput, bug rate, on-call load)

Guardrails:

• CI that runs tests/lint/typechecks
• Human code review before merge
• Reproducible prompts/inputs for agent runs
• Dependency + license scanning

Tier 3: Direct Contribution (Agent Highway to Prod)

This is the most advanced tier: set up a “highway” where agents can contribute changes directly – but only with strong verification and ownership.

• Integrations: Slack, web app, task trackers, CI/CD
• Requires: verification, ownership model, guardrails
• Output: trusted agentic contribution in production
• Metric: time-to-fix, time-to-recovery, # of contributions by non-engineering teams, customer outcomes

Guardrails :

• Sandbox execution with secrets isolation
• Policy boundaries (what agents can/can’t touch)
• Rollback-first mindset + feature flags
• Audit logs for agent actions
• Clear ownership: who’s accountable when an agent ships code

Closing

If you are planning to transform your company with AI-first coding, feel free to contact me to get help and set this up for your specific context: https://kyrylai.com.

Cheers!