The Age of the Micro-Entrepreneur

It’s the last day of 2025, and I’m looking back at a year that fundamentally changed how I think about building software.

This year broke me and rebuilt me. My father died. My long-term relationship ended. I ended up on SSRIs for a while. It was, by far, the most difficult stretch of my life.

But difficulty has a way of forcing change.

I spent most of the year doing consulting work. At first, it felt hollow. But as the months passed and I leaned harder into AI - building new workflows, automating more, creating tools I’d never have attempted before - something shifted. The spark came back. I built more software this year, both commercial and personal, than in any year I can remember.

I’m ending 2025 building my own startup.

The path from depression to here taught me something I want to share: we’ve entered the age of the micro-entrepreneur, and the rules of what one person can build have been completely rewritten.

Let me tell you some stories from this year.

Day One in a Language I’d Never Used

Earlier this year, I walked into a new client’s codebase written entirely in Rust. I’d never written a single line of Rust in my life. I didn’t know the syntax, the keywords, the idioms - nothing.

By the end of that first day, I submitted a pull request refactoring patterns I’d spotted that bothered me. The senior Rust developers on the team - people who’d been writing Rust for years - reviewed it and said: “This is great. We’ve been meaning to do this for a while but couldn’t find the time.”

How? I knew what needed to change. I understood architecture, patterns, code smells. The LLM handled the syntax I didn’t know.

This is what programming has become. Not memorizing keywords and APIs, but understanding systems deeply enough to direct their transformation.

Systems Design is the New Syntax

There’s a common misconception that AI will replace programmers. I don’t think that’s quite right. What’s actually happening is more nuanced: programming is transforming from syntax-first to systems-first.

Let me give you a concrete example from earlier this year.

I started working with LittleBird that builds an AI assistant observing everything you do on your Mac. When I joined, the team was writing parsers in Swift - code that could analyze a visible application on screen and extract meaningful information from it. Each parser took a long time to write. It was meticulous, manual work.

A single parser for one app could take a developer a week.

I looked at this and thought: this is exactly the kind of work that shouldn’t require human engineering anymore. So I re-engineered the entire pipeline.

The new system:

• Parsers are now written in JavaScript instead of Swift
• Why JS? No build step. Isolated execution. Faster iteration. Easier testing.
• An LLM agentic loop does 99% of the work
• Engineers click a few times in our dev app (that I made) to record different snapshots of a target application
• Then they simply say: “write a omnifocus parser”
• Claude handles the rest and in 3.5 minutes they see:

What used to take a week now takes minutes. Not because the engineers are faster at typing - because the nature of the work changed. Their job for parsers has shifted from writing code to curating examples and validating output.

This is what a “10x engineer” looks like now. Not someone who types faster, but someone who redesigns systems so that AI handles the repetitive work.

This has always been my focus but AI really makes Dev Tool + Automation loop so much easier / faster to build.

What One Person Can Build Now

I’ve been programming for 28 years. I’ve seen a lot of productivity tools come and go. But nothing has shifted what’s possible like the progress of AI tooling.

Story 1: The Autonomous Engineering Pipeline

One of my earlier projects this year - before Codex or Cursor’s background agents were any good - was for an enterprise client, a multi-billion dollar company. I built a background daemon that connects to Linear and runs fully autonomous AI workflows.

Here’s what it does:

• Creates PRDs from tickets
• Waits for human review
• Implements the approved spec
• Verifies the implementation
• Opens PRs automatically

Built with LangGraph for orchestration, Claude for deep code understanding, direct LLM API calls via OpenRouter for more deterministic tasks.

There’s something surreal about watching the whole flow execute live in the console. A ticket comes in, the system analyzes it, drafts a spec, waits for approval, then implements and ships. The human becomes the checkpoint, not the executor.

Story 2: The Web App I Never Learned to Build

A client needed a web application with a full CMS. I’ve spent my entire career on native platforms - Swift, Objective-C, games in C++. I’d never built a web app. Never touched modern web frameworks professionally.

I built them a complete system. Full CMS, everything they needed.

When they asked if I used AI, I said: “Of course.”

Their reaction? They didn’t care. It works. They paid for results, not for how many hours someone spent typing.

There’s an old joke about a mechanic who fixes a machine with a single tap of a hammer and charges $1,000. When asked why, he says: “One dollar for the tap, $999 for knowing where to tap.”

That’s where we are now with AI. My architectural intuition - understanding what to build, how it should work, which patterns matter - that’s the tap. AI handles the typing.

Story 3: The 18 Dollar App

I recorded an audio description of an app I wanted to build. Just spoke for a few minutes about what it should do, how it should feel, what problems it should solve.

I fed that into my automation pipeline - transcription, documentation generation, task breakdown, implementation.

Then I went to the cinema.

When I came back, the app was done. Total cost: 18 dollars.

For context: I wouldn’t get out of bed for 18 dollars. That used to be maybe an hour of a junior developer’s time. Now it buys you a complete application, obviously that application is simple and straighforward and nothing innovative but still, I would not spend my own time to build it and it was useful many times this year.

The Flywheel of Efficiency

Early in my career, I realized something that shaped everything since: time invested in optimization compounds.

A task took me 8 hours. I spent 2 hours of my personal time figuring out how to do it faster. Saved 1 hour. Now I had an extra hour during work to optimize further. Then another. The gains compound.

After years of this, I can do in 2 hours what takes others 2 days. And what do I do with the extra time? Either take on more challenges, or go to the gym. That’s the freedom that efficiency creates.

AI became the biggest accelerator this flywheel has ever seen.

This year, I found myself working on multiple projects simultaneously - not because I worked more hours, but because I could describe what I wanted, let AI implement it, review and correct, move on. The bottleneck shifted from “how fast can I type” to “how clearly can I think and articulate.”

We are definitely at the stage where next innovation will be about improving how we review code / architecture in AI world, GitHub way of doing things is outdated for modern world.

My prediction is that we will re-think what code review is, and it will be around leveraging AI but as a review partner and not a bot like what we have now with CodeRabbit etc.

The Micro-Entrepreneur Future

Here’s my prediction: in max 5 years, we’ll see a world of micro-entrepreneurs where the only limit is creativity.

Right now, you still need technical oversight. You need to know enough to validate AI output, catch errors, correct course. That’s a skill barrier, but it’s shrinking fast. Just look at how much it shrank this year alone.

The models make fewer mistakes with each generation. The tooling gets better. The cost keeps dropping.

What does this mean practically?

• A solo founder can build and ship products that used to require a team
• Domain experts in any field can build tools for their specific needs
• The barrier between “having an idea” and “having a working product” approaches zero
• Small teams can compete with large ones by leveraging AI effectively

I have apps I built just for myself - fitness tracking, income aggregation from multiple sources. Problems I wanted solved, solutions I built in hours instead of never.

This is the democratization of creation. Not everyone will become a programmer, but everyone will be able to build things.

What This Means for Programmers

If you’re a programmer reading this, you might feel two things: excitement and anxiety. Both are valid.

The anxiety: yes, the profession is changing. The value of being able to write code - the mechanical skill of knowing syntax and typing it correctly - is approaching zero. Mid-level engineering work, the kind where you’re implementing well-defined specs without much architectural input, is exactly what AI does well.

The excitement: the ceiling for what one person can accomplish has never been higher.

The programmers who will thrive in 2026 and beyond are the ones who:

1. Develop architectural intuition - Understanding what to build matters more than how to type it
2. Learn to orchestrate, not just execute - Your job becomes directing AI agents, validating output, course-correcting
3. Build systems, not just features - Like the parser pipeline, redesign workflows so AI handles the repetitive parts
4. Invest in architecture skills - Knowing patterns, principles, trade-offs - the stuff that transcends any single language

My recommendation: learn to program AI systems, not just use them. Understand how to call models via API, how to build agentic workflows, how to create self-improving systems. This opens your mind to possibilities you can’t see from inside a chat interface.

Embrace the Transformation

I tracked my work throughout this year. The time savings are measured in hundreds of hours.

I took on projects I would have refused before - different languages, different platforms, different domains. The boundaries that used to define what a single person could build dissolved before my eyes.

That’s why I’m ending 2025 building my own startup. Not because I got bored of consulting, but because the math changed. What used to require a team, I can now build myself. What used to require full team can now be lean again, and you can cover most of it using AI agents.

If you’re a programmer, this is the most exciting time to be in our field. Not because the job is getting easier, but because the scope of what’s possible is exploding.

The tools are here. The costs are plummeting. The only question is whether you’ll use them to build something remarkable.

I went to the cinema and came back to a finished personal app.

What will you build in 2026?