The Art Teacher Was Wrong
When I was eight, my art teacher told me I wasn't artistic. I believed her for thirty years.
In 2025, I shipped creative code I never thought I could write—WebGL experiments, generative visuals, apps to platforms I'd never touched. visionOS. tvOS. watchOS. Weekend projects on platforms where I had zero experience a year ago.
What changed wasn't me. It was the constraints.
This isn't a productivity story. It's a liberation story. And if you're reading this at the end of 2025, you've probably felt it too: the strange sensation that the gatekeeping that used to define what you could build is quietly dissolving.
Deep expertise still matters—and will continue to. But the barrier to entry has lowered in ways that would have seemed impossible even two years ago. The constraint "I've never done this before, so I won't make anything good" no longer applies in the way it used to.
This is just the beginning.
The Wrong Question
Someone asked me earlier this year: "How much faster does AI make you?"
I've thought about this a lot, and I've concluded it's fundamentally the wrong question. You can be fast, but you risk being sloppy. Speed without direction is just faster chaos. Quality drops.
The real shift isn't speed. It's leverage.
AI has helped me do more, make better products, and be more informed as I'm designing and building. I can plan out features, test ideas, understand trade-offs, and wade into unfamiliar codebases with greater confidence. When focused on intent and direction rather than the mechanics of writing code, it's easier to stay intentional about the product and make steady progress.
It's not about being fast. It's about being empowered. Freeing up mental space from the mechanics of implementation creates room to be intentional about direction. Fewer constraints on what I can build means more focus on what I _should_ build.
The question isn't "how much faster?" The question is "what's now possible that wasn't before?"
The Agent Fleet
Here's what 2025 looked like in practice: I manage a team now. One handles my email and flags what matters. Another reviews code and catches regressions. A third researches topics in minutes.
None of them are human.
This is what being a CTO of your own agent fleet looks like.
AI agents proved their value this year. The standouts:
- Poke for personal workflows. What sold me was realizing I no longer actively manage my email—my agent watches for what matters, and I can query it when needed. In 2025, email isn't a major channel for personal communication anyway; it's mostly marketing and the occasional important message. A natural domain to delegate.
- Claude Code and Codex for coding work. Both have text-based interfaces that work well for iterative development. I switch between them as the models improve. Claude Code excels at working within existing codebases. Codex can work for hours—useful for codebase-wide refactors.
- Devin surprised me the most. At the start of the year, it seemed like a rudimentary Sonnet-based agent harness. By year's end? The most flexible of all of them. It improved at gathering context and indexing codebases. It now uses multiple models—including a secondary model it can consult for second opinions. It's faster, cheaper, and better at one-shotting smaller changes. But what excites me most is seeing Devin evolve into a surface for managing multiple agents and orchestrating cross-domain automation: a Linear ticket triggers Devin to analyze the issue and create a PR, an automated code reviewer provides feedback, and Devin addresses it. These workflows are still nascent, but they point toward something significant.
The key insight: treat these agents like coworkers rather than tools.
Conductor (from Melty Labs) deserves a mention for enabling parallel work across multiple coding projects simultaneously—particularly useful for those who struggle to work on just one thing at a time.
Model Specialization
I used to just reach for "the smartest model." Now they all have distinct strengths and weaknesses, and picking the right one is becoming a skill in its own right.
- Gemini performs well at front-end design. When creating a new UI, that's often where I start.
- Opus is strong at general coding and working within existing codebases.
- GPT-5.2 excels at hard reasoning problems—though its code tends toward density. Useful for problems other models struggle with.
- GPT-5.2-codex can work for hours. Effective for marathon refactors across a whole codebase.
How do you learn this? Trial and error. When a new model comes out, spend time testing it against your specific tasks. Over time, you develop intuition for what each one does well.
In 2026, I expect this to become an explicit, teachable skill—similar to how we learned to pick the right database for the job.
The Creative Stack
2025 was also the year AI creative tools crossed quality thresholds. These are no longer novelties—they're production tools.
Suno for audio. There's an analog warmth to what it produces. Suno v4 (released November 2024) and the subsequent v4.5 update brought studio-grade audio at 44.1 kHz, extended tracks up to 8 minutes, and improved vocal realism. Useful both for listening and generating soundbeds.
Sora for video. Sora Turbo launched in December 2024, and Sora 2 (September 2025) introduced synchronized audio and the ability to inject real people and objects into generated scenes. The Disney licensing deal announced in late 2025 hints at where this is headed.
Nano Banana (Gemini's image generation) for images. High-quality output with strong text rendering—a historically weak point for image models. I've built automated pipelines with it for app store assets: icons, screenshots, marketing materials. It's become infrastructure.
The through-line across these tools: quality output, usable interfaces, and the kind of stickiness that separates novelty from workflow. These made the cut.
The Mental Shift
Here's a shift that might be uncomfortable: the code matters less than it used to.
Code has become cheap and fast enough to change that the focus shifts elsewhere. Models are generally competent at producing decent code. The leverage is in directing the agents rather than micromanaging implementation details.
Guard rails handle quality: tests, lints, formatters, AI rules. Put the systems in place, and the output takes care of itself.
This isn't a new principle. In any leadership role, you learn not to micromanage—you put systems in place and trust them. The difference now is that the "team" includes non-human agents.
I've also come around on text and chat-based UIs. Initially, I thought they were lazy design. Now I appreciate them for what they enable: natural language makes it easier to express intent, and the abstraction level is finally high enough that implementation details can fade into the background.
Expect more generative UI in 2026—richer interfaces that emerge from conversation rather than being hand-built.
The Infrastructure That Made It Work
Two pieces of infrastructure deserve credit for enabling the agent era: MCP and Skills.
MCP (Model Context Protocol), released by Anthropic in November 2024, has seen rapid adoption. It connects coding agents to documentation, build tools, Linear, Notion, and more. OpenAI adopted MCP in March 2025, and by December, Anthropic donated the protocol to the Linux Foundation's Agentic AI Foundation. MCP showcases one of the main agent value-adds: tool integration that actually works.
Skills feel more open-ended than MCP. They're not just about tools—they're about process and protocol. An agent can adopt different operating rules and roles depending on the task. Useful for bringing in specialized expertise. Worth watching where this standard goes in 2026.
The Unsolved Problem
Here's a reasonable prediction: within six months, AI will be able to handle most of the act of writing code. We're close already.
Self-improving systems are emerging—AI that fixes test failures, continually tunes itself. The trajectory is clear.
But this doesn't mean software engineers become obsolete. The _act_ of writing code becomes automatable. Direction, judgment, and coordination remain human. We still have humans in the loop directing the agents.
So coders evolve into architects and PMs. Or a new role emerges—in a previous essay I called this the Portfolio Engineer: extreme ownership of components, able to iterate fast with AI.
But here's the problem we haven't solved: empowerment without coordination creates chaos.
On one hand, empowerment is valuable. Engineers are taking on the role of architect, product owner, moving fast. On the other hand—especially in larger organizations—it's hard to track all the product changes and potential regressions. Everyone shipping everything means nobody knows what's shipping.
For every organization, this looks a little different. There's no universal playbook yet. This remains a wide-open problem.
2026 Predictions
So where are we headed? Here's what I expect:
More powerful models will make current friction disappear. Many of the annoyances we work around today—context limits, hallucinations, inconsistent quality—will simply improve as models get better. Avoid over-engineering solutions to problems that won't exist in six months.
Agent Control Planes. Tools like Linear will market themselves as orchestration layers for humans _and_ agents. Manage tasks and agents in one place. The "control plane" framing is going to become common.
Cross-domain automation matures. The nascent workflows I mentioned with Devin—where a Linear ticket triggers analysis, a PR, automated code review, and iterative fixes—will become more robust and widespread. Expect tighter integration between task management, coding agents, and CI/CD systems.
Code review and guardrails explosion. Expect more products focused on the verification side—visual regression testing, AI code review, automated quality checks. The bottleneck is no longer writing code; it's ensuring quality at scale.
Generative UI takes off. ChatGPT Apps could be like iOS App Clips, except they actually work. Richer chat interfaces that generate UI on the fly. This has been a dream for years; 2026 might be when it lands.
IP licensing boom. On the heels of Disney licensing their IP for use in Sora videos, expect other brands and celebrities to follow. Figuring out monetization for AI-generated content will be a major theme.
Portfolio Engineer emergence. Here's a hypothesis worth testing: if AI chaos is bounded by clear ownership, does it self-correct? If changes stay scoped to well-defined areas of ownership, the responsibility for bugs and maintenance becomes clear—and people act more responsibly.
I'm committing to test this in 2026. If it works, it could be a model for how teams operate in the agent era.
Model orchestration becomes explicit. Like picking the right database, picking the right model for a task becomes a teachable skill with clear best practices.
More AI-assisted attacks. Unfortunately, bad actors will get more sophisticated too. Security becomes even more critical.
The through-line: 2026 is the year we discover how to work with non-human coworkers. Not whether we can—we know we can. But how to do it well.
Everyone Can Be a CTO Now
The role is changing. Code-writing is becoming commodity. Direction is becoming premium.
This isn't threatening—it's an opportunity.
The question is shifting. It used to be "can I build this?" Now it's "what should I build?"
The constraints are dissolving. The possibility space is expanding. Platforms and skills that once required years of ramp-up are now accessible to anyone willing to learn how to direct agents effectively.
2026 is about discovering how to work with non-human coworkers. It's about testing whether scoped ownership can tame the chaos of AI-assisted development. It's about building the infrastructure—Agent Control Planes, guardrails, evidence loops—that lets us ship faster without shipping slop.
Everyone can be a CTO now. The question is: of what?