The Day Git Became My Bottleneck

I currently run 9 git worktrees locally.

Nine folders.
Nine branches.
Nine concurrent streams of work.

Each one often powered by a different AI agent.

One is refactoring backend logic.
One is rewriting UI.
One is cleaning up types.
Another is experimenting with architecture.
Two more are writing tests.

The problem?

It wasn’t merge conflicts.

It was this:

git checkout develop
git pull
git checkout -b feature-x
git add -A
git commit
git push
gh pr create

Over.
And over.
And over.

In nine different directories.

When you cross 5 parallel tasks, something subtle happens:

Your brain becomes the bottleneck.

Not code.
Not architecture.
Not AI.

Your memory.

• “Did I pull in this folder?”
• “Does this branch already have a pull request?”
• “Is this branch up to date?”
• “Did I forget to open a pull request?”
• “Is CI going to fail because I forgot typecheck?”

This is not engineering.

This is cognitive tax.

And it scales linearly with the number of parallel contexts.

Multi-Agent Development Changes Everything

In single-threaded human development:

One branch at a time is fine.

In multi-agent development:

You’re effectively managing a distributed system — locally.

Each branch becomes a micro-environment.
Each worktree becomes an isolated runtime.

And if your workflow isn’t automated:

Chaos compounds.

The core issue isn’t Git.

It’s context management at scale.

The Shift: Disposable Contexts

The mental breakthrough was simple:

A branch is not an asset.
A branch is a disposable container.

Each task must:

• Start clean
• Be isolated
• Be reproducible
• Be safely merged
• Be destroyable

No stacking.
No emotional attachment.
No “I’ll reuse this branch”.

Disposable.

So I Built Skills to Remove Myself From the Loop

Instead of manually managing Git state across 9 worktrees,
I encoded the workflow into commands.

Now I only use four:

/new-branch
/typecheck-lint
/typecheck-lint-commit-push
/commit-push

That’s it.

Here’s how it works.

1️⃣ /new-branch — The Clean Start Protocol

When I begin a new task:

claude /new-branch

It automatically:

• Checks for uncommitted changes
• Switches to develop
• Pulls latest remote state
• Generates semantic branch naming
• Creates an empty commit
• Creates a draft pull request

Why the empty commit?

Because I want the pull request immediately.

CI should start early.
Review can start early.
Context is established early.

No forgotten pull requests.
No stale branches.
No accidental stacking.

Every task begins from a clean, synchronized state.

2️⃣ /typecheck-lint — Local Sanity Gate

During development:

claude /typecheck-lint

This runs:

• TypeScript type checking
• Linting
• Automatic fixes when possible

And here’s the important part:

It uses my ProductReady boilerplate as the golden standard.

That means:

If structure drifts,
If patterns deviate,
If something violates our production architecture baseline,

It corrects toward that standard.

This isn’t just linting.

It’s architectural alignment.

No commit is created.
It’s purely local validation.

3️⃣ /typecheck-lint-commit-push — Safe Commit Mode

When I want CI to pass on the first try:

claude /typecheck-lint-commit-push

It:

• Runs typecheck
• Runs lint
• Blocks if errors exist
• Commits
• Pushes
• Creates or updates the pull request

This is my default mode.

The goal:

CI passes on first run.

In a multi-agent environment, failed pipelines are expensive.
Each failure interrupts flow across contexts.

4️⃣ /commit-push — Fast Path

For quick changes:

claude /commit-push

It:

• Adds all changes
• Generates semantic commit message
• Pushes
• Creates or updates pull request

No friction.
No mental overhead.

The Multi-Worktree Rhythm

Here’s the actual cycle across 9 directories:

Start new task

/new-branch

Develop

AI agent works.

Validate

/typecheck-lint

Safe commit

/typecheck-lint-commit-push

Merge

Pull request is merged.
Remote branch auto-deleted.

Cleanup

Optionally remove local worktree.

Done.

Zero ambiguity.

What Changed After This

Not code quality.

Not commit speed.

But this:

My cognitive load dropped dramatically.

I no longer think about:

• Branch state
• Pull request existence
• Whether develop is fresh
• Whether CI will fail on obvious type errors

I only think about:

• Product
• Architecture
• System evolution

The Deeper Insight

Multi-agent development isn’t about AI writing code.

It’s about scaling context safely.

When you move from:

1 branch → 9 branches
1 task → 9 tasks

You need:

• Deterministic start states
• Automatic pull request guarantees
• Local validation gates
• Disposable environments

Otherwise:

Human memory becomes the weakest link.

This Isn’t About Git

It’s about infrastructure for velocity.

When AI increases output speed 5x,

Your workflow must evolve accordingly.

If not:

You’ll drown in your own parallelism.

Final Thought

The future of development isn’t single-threaded.

It’s multi-context, multi-agent, multi-branch.

And in that world:

The best workflow is the one
that removes you from repetitive control loops.

Because your brain is too expensive to waste on git checkout.

If you’re running more than three parallel branches,

try this experiment:

Automate your branch lifecycle.

Make context disposable.

And watch how much mental space you reclaim.

I, along with others in the industry, argue the opposite. (For context: I’ve spent years building and investing in AI automation companies, including some of the aforementioned). We believe the new generation of coding agent companies are creating real, high-growth businesses with deep moats. In fact, the broader market remains cautious — enterprise software stocks trade at moderate multiples, and many commentators constantly warn of AI hype. And as the old maxim goes, you can’t have a bubble when everyone is screaming “Bubble!” The discussion shouldn’t fixate on frothy valuations alone, but on the underlying tectonic shift: we are in the midst of a dramatic technological and economic transition in which coding agents are poised to take over large swathes of work across the economy.

In industry after industry, software workflows that once depended on human labor or traditional programs are now being run by AI coding agents delivered as online services. Many of the winners are entrepreneurial tech companies from Silicon Valley (and increasingly, globally) that are invading and overturning established structures. Over the next 10 years, we expect coding agents to disrupt countless domains — often led by new upstarts rather than incumbents.

Why Is This Happening Now?

Why are coding agents taking off now, rather than five or ten years ago? Simply put, all the necessary ingredients have finally come together, after decades of groundwork in computing and AI. Recent advances in large language models (LLMs) mean we now have AI that can reliably understand instructions and generate complex code. Six decades into the computer revolution, and after two decades of exponential internet growth, the technology needed to let software write its own software actually works — and can be deployed at global scale.

Several key enablers converged to make coding agents feasible:

• Ubiquitous Connectivity and Computing: Over 5 billion people carry smartphones connected to cloud data centers. High-speed internet and cloud platforms mean an AI agent can be accessible to anyone, anytime. In the early 2000s, launching a web startup required investing in costly servers and infrastructure. Today, an AI agent can be spun up on a cloud instance for a trivial cost. (When my colleague co-founded a cloud computing firm in 2000, it cost ~$150,000 per month to run a basic web app; now developers can rent a powerful cloud GPU for a few dollars an hour.) The global digital infrastructure envisioned in the 1990s is finally here — the world is fully online for these agents to live in.
• Mature AI and Tools: Modern AI models are not science projects; they are battle-tested and developer-friendly. Open-source frameworks and APIs (from OpenAI, Anthropic, Cohere, etc.) let small teams build on top of frontier models without reinventing the wheel. Programming assistants went from gimmicks to genuinely useful in just a few years. As one example, GitHub’s AI pair programmer Copilot now writes almost 46% of the average developer’s code (and over 60% in Java projects) for 15 million users. This would have sounded like science fiction a decade ago. Coding agents leverage these same advances — using AI to generate and execute code — to handle tasks end-to-end.
• Falling Costs: The cost of computing intelligence has plummeted. Training a top-tier AI model used to cost millions of dollars, but today any startup can rent cloud AI APIs on a pay-as-you-go basis or fine-tune open-source models cheaply. Running a basic coding agent — complete with a virtual machine sandbox, browser, and database — is orders of magnitude cheaper than it was even a few years ago, thanks to cloud providers and containerization. Lower startup costs + a vastly expanded market = fertile ground for dozens of new agent-powered services.
• Cultural Readiness: Crucially, people and businesses are more receptive now. Hundreds of millions have used Siri, Alexa, or ChatGPT, acclimating them to the idea of talking to an AI. Businesses have spent a decade moving workflows to SaaS and automation. The remaining leap — from automated software to autonomous software — is smaller than ever psychologically. We’ve gone from “there’s an app for that” to “my AI agent handled that.” In short, the world is ready for software that acts on its own.

Perhaps the single most dramatic evidence of this readiness is the case of OpenClaw. In January 2026, this open-source personal AI agent (formerly known as ClawdBot/MoltBot) became the fastest-growing project in GitHub’s history. OpenClaw is essentially “Claude with hands” — a reference to Anthropic’s Claude model, augmented with the ability to take actions on your behalf. Once installed on a user’s machine, it can execute terminal commands, run scripts, browse the web, read/write files, integrate with email and messaging apps, and generally act as your digital assistant. In other words, it turns natural language instructions into actions across your digital life. Despite its technical setup, OpenClaw amassed a staggering user base in days, as knowledge workers and developers rushed to give themselves a “virtual AI coworker.” This grassroots adoption underlines that the tech finally works and people are eager to use it — even outside of polished commercial products.

Agents Transforming Industries

The rise of coding agents isn’t just a novelty for programmers — it’s already reshaping major businesses and workflows. In industry after industry, we see the pattern repeating: an AI agent emerges that can perform core tasks with software, faster or cheaper than traditional methods, and incumbents either adapt or get left behind. Consider a few examples:

1. Software Development and IT. It’s fitting that coding agents are disrupting the software industry itself first. We already noted how AI coding assistants are writing a large fraction of developers’ code. But beyond assisting humans, agents are starting to autonomously build and maintain software. For instance, teams now deploy agents to automatically generate simple apps or microservices from specifications, to handle code refactoring at scale, and even to monitor and fix bugs overnight without human intervention. DeepMind’s AlphaDev system showed that AI can go beyond human developers in some areas: it discovered new sorting algorithms that outperformed decades-old human benchmarks, leading to improvements in the standard C++ library. This kind of innovation hints that no aspect of coding is off-limits for automation.

DevOps and operations are similarly being eaten by agents. Instead of a human writing a bash script to deploy servers or update configs, an AI agent can write and execute those scripts on the fly. Instead of a knock in the middle of the night to handle an outage, an agent can detect the issue and apply a fix (or at least triage it) before anyone wakes up. Startups like Adept AI recognized this early, raising hundreds of millions of dollars to build AI “teammates” that use existing software and APIs on your behalf. The vision is an AI that can do anything a human user can do on a computer — click buttons, type commands, cross-communicate between apps — only faster and tireless. We’re already seeing this in action: for example, an agent that takes a CEO’s simple Slack message “Set up a new cloud database for our analytics” and goes off to provision the database, configure it, and connect it to the company’s dashboard, all automatically. The boring glue work of IT is on the verge of being fully automated.

2. Knowledge Work and Business Processes. Coding agents are not limited to “coding” per se — they use coding as a tool to get any digital task done. That makes them incredibly general-purpose for knowledge-based industries. A standout example is in recruiting and HR: Manus (one of the leading cloud-based agents) can take a folder of job applicant résumés and, in a matter of minutes, read every résumé, analyze each candidate, and compile a detailed ranking in a spreadsheet. If the hiring manager then says, “Actually, prioritize people with fintech experience,” the agent dynamically updates its criteria and re-scores the candidates. This is a task that might take a human HR team days of effort; Manus does it continuously and objectively as new résumés come in. It’s not hard to imagine every HR department using an AI agent for first-pass candidate screening and research in the near future. The $400 billion recruiting industry that LinkedIn began to chip away at is now squarely in an AI agent’s sights.

Finance and analytics are likewise being transformed. Instead of a junior analyst pulling data and running Excel models all night, a coding agent can crunch financial reports, execute complex Python analyses, and generate presentation-ready charts on demand. Ask such an agent to “analyze Tesla’s stock performance and build a web dashboard of key insights,” and it will fetch market data, perform calculations, and even produce an interactive website to visualize the results. This isn’t hypothetical; Manus demonstrated exactly that capability in a demo. The turnaround time for deep analysis has gone from weeks to hours or minutes. Entire layers of middlemen — consultants producing reports, business analysts prepping dashboards — can be streamlined by agents that never clock out and integrate directly with databases and APIs.

Marketing and customer engagement have embraced AI in content creation, and now coding agents push it further into execution. We’re seeing early agents that manage marketing campaigns autonomously: they generate personalized emails, iterate A/B tests on websites by deploying new code, allocate budget across ad platforms by interfacing with their APIs — all based on high-level goals given by a human strategist. In e-commerce, for example, an AI agent might handle the full cycle of a flash sale: it writes the promotional copy, codes the landing page, adjusts prices in the backend, and sends out customer notifications. Traditional marketers and web teams simply could not move that fast. The companies that leverage these agent-driven workflows can run circles around those that don’t.

Customer support and operations are also feeling the impact. Chatbots have been used for support for years, but a coding agent can go further by acting on the customer’s issue. If a customer says, “I’m having trouble with my account,” a capable agent can directly query the backend systems (via code or API), diagnose the problem (say a misconfiguration), fix it, and reply to the customer that it’s resolved — without any human in the loop. This blurs the line between customer service and DevOps, because the “support agent” is literally an AI with system access and coding skills. Companies are cautiously starting to roll this out for common issues, because it can drastically reduce response times and costs. Those that perfect it will gain a huge advantage in customer satisfaction.

3. Personal Productivity and Daily Life. On the individual level, coding agents are becoming the new power tool for knowledge workers, much like spreadsheets or web browsers were in earlier eras. We already highlighted OpenClaw, which tech enthusiasts are using as a personal secretary to automate chores: it clears your inbox, schedules meetings by cross-referencing calendars, checks you in for flights, and even orders your groceries via web scripts. All from a natural language chat interface on WhatsApp or Telegram. In effect, early adopters are each equipping themselves with a tireless digital chief-of-staff. It’s telling that Token Security (an identity security firm) found that over 20% of employees at some companies had started using Clawdbot/OpenClaw on their own — a shadow IT phenomenon where workers bring their own AI to the office to boost productivity. This bottom-up adoption is a strong signal: when people actively seek out a tool (despite no mandate from IT) simply because it helps them get more done, that tool is here to stay.

The education and training sector is likely next for agent-driven change. We already see AI tutors (like Duolingo’s chatbot or Khan Academy’s AI assistant) that provide one-on-one instruction. A coding agent can take this further by not just answering students’ questions but helping them learn by doing. Imagine a personal coding mentor agent: a student gives it a project idea, and the agent generates a starter code, then asks the student to modify it, debugging together in real time. The agent can create custom exercises on the fly, tailored to that student’s mistakes and interests. This kind of highly personalized, active learning at scale has never been possible before. It could revolutionize how we train the next generation of engineers (and indeed any knowledge profession), ensuring more people can participate in the AI-driven economy.

Even in sectors rooted in the physical world, the influence of coding agents is spreading. Automotive is a prime example: cars have essentially become computers on wheels, running millions of lines of code. Now, AI agents are being introduced to manage some of those systems. Modern driver-assistance (and autonomous driving prototypes) rely on AI decision-makers — agents deciding when to brake, turn, or reroute based on sensor data. You can think of a self-driving car as a specialized robotics agent that continuously writes a “script” (drive commands) to achieve the goal of a safe journey. As that technology matures, the role of human drivers will diminish; the agent will effectively “eat” the job of driving, just as cruise control and autopilot started doing decades ago. The difference is the intelligence and adaptability now on display. Tesla’s AI, Waymo’s autonomous system, and others learn and update much like a coding agent refining its approach to a task.

In logistics and manufacturing, agent software is optimizing the physical flows. Warehouses run by Amazon or Alibaba are orchestrated by algorithms that assign tasks to robots and workers; increasingly these algorithms are driven by AI that can rewrite its own logic to improve efficiency. FedEx and UPS have for years used software to map delivery routes — now they are testing AI that dynamically re-routes fleets in response to traffic or weather, writing new logistics plans on the fly. Factories are introducing AI co-pilots for production lines, which can programmatically adjust machine settings in real time to reduce defects or energy use. These are domain-specific agents, but they operate on the same principle: take in data, decide on actions, and execute via code — no human needed for each decision. In short, wherever there’s a repetitive decision process, an autonomous software agent is a potential replacement or assistant for the humans currently doing it.

It’s important to note that in some of these heavy industries, the incumbents have an opportunity: unlike, say, Blockbuster being blindsided by Netflix, a savvy car manufacturer or bank can deploy coding agents internally to stay ahead. For example, oil and gas companies were early adopters of supercomputing; today they are using AI to analyze seismic data and even to automate the control of drilling equipment. In agriculture, farmers now use AI-driven drones and planting bots that act on soil and weather data in real time. These are cases where the existing players use the new tech as a force multiplier rather than getting displaced by a startup. Nonetheless, the pattern holds: software (often AI software) is doing more of the critical work.

The Next Frontiers and Challenges

As we look ahead, no industry is truly safe from this trend. Healthcare and education — two sectors that have lagged in digital disruption — appear primed for an AI agent revolution in the coming years. We’re already seeing early signs: AI models can draft clinical reports and assist in diagnosis from medical images; combine that with an agent that can cross-reference patient history, schedule follow-up tests, and draft prescription orders, and you have the makings of an automated medical assistant. Likewise in education, beyond tutoring, an agent might handle all the administrative drudgery for teachers (grading assignments, composing individualized feedback, preparing lesson plans that adapt to live class progress). These fields are heavily human-centric by nature, so AI won’t replace the empathy and big decisions of professionals anytime soon. But by eating up the routine “paperwork” and providing decision support, coding agents could free up humans to focus on what they do best in these domains. My venture firm is backing startups in both healthcare and education that use AI agents to tackle precisely these pain points — areas traditionally resistant to change but now ripe for transformation by entrepreneurs who pair domain expertise with AI savvy.

Even national defense and cybersecurity are becoming arenas for coding agents. Modern militaries already employ autonomous drones and AI-powered analysis. The next step is agents that write code to counter threats at machine speed. For instance, the Pentagon’s DARPA recently launched the AI Cyber Challenge, inviting teams to build AI agents that can automatically find and fix software vulnerabilities to defend critical infrastructure. Think about that: instead of waiting for human cybersecurity analysts to patch a flaw (a process that can take months, during which we’re exposed), an AI agent could detect the flaw and generate its own patch in hours or minutes. It’s a high-stakes example of coding agents potentially “eating” the cybersecurity workflow. Of course, this cuts both ways — malicious actors might use AI agents to discover exploits or even to conduct cyberattacks autonomously, which raises the urgency for defense to deploy equally capable agents. We’re entering an era of AI agents dueling behind the scenes of warfare and crime-fighting, each writing and executing code at speeds no human can match.

For companies in every industry, the lesson is clear: assume an AI agent revolution is coming to your sector. Just as every company had to become somewhat of a software company over the last 20 years, now every company will need to become an AI-driven company over the next 10. This applies even to today’s software leaders. Great software incumbents like Microsoft, Google, Salesforce, and Oracle are racing to infuse agents into their products. Microsoft is rolling out Copilot agents across Office and Windows; Google is embedding generative AI into Workspace and search. They have no choice — if they don’t, upstarts will. We’ve already seen how Stack Overflow’s traffic fell by half once developers could get coding answers from ChatGPT and agents rather than traditional Q&A sites. That’s a stark reminder: even digital-era firms can be disrupted if they stick to old paradigms. Google itself reportedly declared a “Code Red” internally when OpenAI’s ChatGPT burst onto the scene, fearing the threat to its search empire. The incumbent advantage can evaporate quickly when a new technology enables a fundamentally better user experience. AI agents that deliver instant, on-demand actions (not just information) are exactly that kind of leap.

In some domains, especially those entailing heavy physical assets or regulated environments, the incumbents might harness coding agents as an efficiency booster rather than face an upstart. But in many other domains, we expect new agent-native startups to completely upend the old order. The battles between established firms and AI-powered insurgents will be fierce. History suggests not all incumbents will adapt in time — many will fall into the innovator’s dilemma, hesitant to fully embrace automation that might cannibalize their legacy revenue or jobs. Meanwhile, nimble startups will have no such qualms about deploying AI to the hilt. The coming decade will likely see some titanic showdowns: think a traditional enterprise software giant versus a lean AI agent platform that can customize and integrate itself at a fraction of the cost; or a legacy bank versus a fintech that runs on AI agents for everything from customer service to risk modeling. Joseph Schumpeter’s concept of “creative destruction” is alive and well. He would recognize these AI agents as the new engines of creative destruction, tearing down old structures to make way for new ones.

Despite the turbulence this will cause, it’s ultimately a profoundly positive story — for those societies and companies willing to embrace it. In particular, it’s a huge opportunity for the tech ecosystem that nurtures such innovation. It’s not an accident that many of the breakthroughs in AI agents so far have come from the United States (think OpenAI’s ChatGPT and code interpreter, Microsoft and Google’s integrations, countless Silicon Valley startups) — the U.S. still benefits from world-class universities, a risk-taking culture, deep pools of venture capital, and strong legal protections for entrepreneurship. However, this wave is more global than the last. We’ve seen a Shenzhen-based team launch Manus and achieve world-leading autonomy, and open-source communities across Europe and Asia collectively push projects like OpenClaw. Innovation can come from anywhere, and capital is certainly paying attention globally. The U.S. doesn’t have a monopoly on AI talent or ambition — which is all the more reason American companies and policymakers must not become complacent. Still, those regions that foster the right mix of talent, capital, and pro-innovation policy will attract the best AI agent companies. It bodes well for places like the U.S., and also for new hubs around the world that position themselves as friendly to AI startups.

That said, we face several challenges in this transition:

• Economic Headwinds and Resilience: Many coding agent startups are being built in a time of economic uncertainty and tighter capital (the post-2021 higher interest rate environment, cautious VC funding, etc.). This is a double-edged sword. On one hand, it’s harder to raise money and scale in a tougher economy; on the other hand, the startups that do make it through will have been forged in fire, with efficient operations and real product-market fit. Just as the likes of Google and Amazon emerged stronger after the dot-com bust, the winners of today’s AI agent cohort will likely be extremely robust. And when the macroeconomy stabilizes or rebounds, watch out — those startups will be poised to grow like wildfire, having already optimized for survival. In short, lean times produce tough companies. We’re already seeing a flight to quality: investors support the teams with real technology and paying users, while mere “AI hype” companies struggle. This is healthy in the long run.
• Talent and Job Disruption: A painful paradox of the AI agent revolution is the mismatch of skills in the labor force. Every tech company I know is starved for AI and machine learning engineers, prompt engineers, and savvy product builders who know how to leverage AI. Talented individuals in this field can command multiple offers and high salaries, even as overall tech unemployment remains elevated in some areas. At the same time, workers in roles that agents are automating (customer support reps, entry-level programmers, data analysts doing routine reporting, etc.) are at risk of being stranded on the wrong side of this disruption. We are likely to see some job displacement as certain tasks become fully automated. This is similar to how assembly-line automation affected manufacturing jobs. The only real solution is education and retraining at scale. Our society needs to equip people with the skills to work with AI agents — whether that’s learning to supervise them, to do the creative and complex tasks the AI can’t, or to build new businesses on top of them. Unfortunately, our education systems tend to move slowly. We have a long way to go to prepare the workforce for the agent-infused economy. In the interim, companies may face talent shortages in AI roles alongside layoffs in legacy roles — a jarring contrast. Managing this transition humanely and intelligently is going to be a major challenge of the coming decade.
• Trust, Culture, and Execution: The new generation of AI agent companies still need to prove their worth in the real world. It’s not enough to demonstrate a flashy demo or raise a mega funding round; they must build strong company cultures, solve real customer problems, and establish durable advantages. There are technical hurdles too: ensuring reliability, accuracy, and security of autonomous agents is brutally difficult. We’ve already seen incidents of agents going off-script or being prompted to do malicious things via “prompt injection” attacks. Earning user trust will require robust safety controls and transparency. For example, Manus built a reputation for showing its work (with a side panel revealing the agent’s “thought process” as it browses and codes) to alleviate the black-box fear. OpenClaw’s rise came hand-in-hand with serious security concerns due to its unfettered access on local machines. Companies in this space must delight customers with useful results and convince them it’s safe to hand over the keys. They also have to justify those rising valuations with real revenue and growth. No one should expect building a high-growth, AI-powered company in an established industry to be easy — it’s brutally difficult, just as building any great company is. The hype can attract competition and scrutiny (from regulators, security researchers, the press). Only the teams with exceptional execution and ethical grounding will survive and become the foundational companies of this new era.

Having worked closely with some of the best emerging coding agent teams, I can report that they are the real deal. These founders and engineers are deeply aware of both the potential and the pitfalls, and they’re pushing the state of the art daily. If they perform to our expectations, they will become highly valuable cornerstone companies in the global economy, eating markets far larger than what the “software industry” used to touch. A company like OpenAI or Anthropic (building core AI capabilities) or a Manus or Adept (building broad agent platforms) isn’t just creating a single app — they’re creating a force that can infiltrate every other app and sector. That scalability of impact is something venture investors dream of, and it’s why the upside is so enormous if they succeed.

Instead of constantly questioning whether their valuations make sense, we should strive to understand how this new generation of technology works, what broader consequences it will have for businesses and the economy, and how we can collectively encourage more innovation in this space. We need to update regulations (in sensible ways) to accommodate autonomous agents, invest in education to broaden the talent pool, and ensure competition so that no single company monopolizes AI. The opportunity is to create an abundance of new services and capabilities that benefit everyone — from more personalized healthcare, to more efficient businesses, to creative tools that empower individuals. The coding agents are here; the genie is out of the bottle. The question is how to maximize the upside and manage the challenges.

That’s the big opportunity in front of us. I know where I’m putting my money: into the teams and technologies that are building and harnessing coding agents. Just as software ate the world over the last 20 years, AI coding agents are now devouring the next crop of opportunities. And unlike in the past, when software was a tool that required a human at the wheel, these new agents are increasingly the drivers themselves. It’s going to be a wild, exciting ride — and it’s only just beginning.

Looking at AI Through the Lens of Human Jobs

Over the past year, AI products have exploded.

Every week, a new AI tool promises to:

• write better content,
• generate designs instantly,
• build websites in minutes,
• turn ideas into working demos with almost no effort.

The first experience is often impressive.

“Wow, this is smart.”

But then comes the uncomfortable reality.

Will users come back tomorrow?
Next week?
Next month?

For most AI products, the answer is no.

Retention is low — sometimes shockingly low.

And yet, many teams keep asking the same questions:

• Is the model not powerful enough?
• Do we need better prompts?
• Should the UX be smoother?

What if none of these are the real problem?

Retention Is Not an AI Problem. It’s a Job Problem.

To understand why most AI products struggle with retention, we need to step outside AI for a moment and look at something much older:

human jobs.

Not employee satisfaction.
Not churn rates.
But which jobs are designed to last.

Employee Retention vs. Job Retention

When people talk about retention, they usually mean employees:

• how long someone stays at a company,
• how often people quit,
• burnout and morale.

That’s not what we’re talking about here.

This article uses a different definition:

Job retention describes whether a responsibility must be continuously fulfilled inside an organization.

People change.
Titles change.
But if a responsibility cannot stop, the job has high retention.

In short:

Retention is about responsibility continuity, not personal loyalty.

Four Questions That Predict Retention

Any job — human or AI — can be evaluated with four simple questions.

First, does the role exist long-term?
Will this responsibility still matter in five or ten years, or will it be outsourced, deprioritized, or removed as the company grows?

Second, is the work recurring?
Does it need to be done daily, weekly, or monthly — or only “when needed”?

Third, what happens if the work stops for two weeks?
Nothing?
Some inconvenience?
Or a serious operational, financial, or legal issue?

Finally, is there a clear accountability chain?
When something goes wrong, can responsibility be traced, audited, and assigned?

Jobs that score high on all four dimensions naturally have high retention.

This Pattern Is Obvious in Human Organizations

Some roles persist in every serious company:

• accounting,
• finance,
• legal,
• infrastructure and operations,
• core backend systems.

These jobs are not popular because they’re exciting.

They persist because the organization cannot function without them.

If they stop, things break.

Other roles are valuable but structurally fragile:

• content creation,
• brand strategy,
• creative marketing,
• social media management.

These roles are often project-based.
Their output is hard to audit.
And if they pause, the company usually survives.

They are useful — but naturally low-retention.

“But What About Software Engineers?”

Software engineers are often assumed to be high-retention roles.

In reality, software engineering is not one job — it’s a spectrum.

Engineers who build demos, prototypes, or proofs of concept often work on short-lived projects.
Once the demo is done, the responsibility ends.

Product engineers working on SaaS features or internal tools sit somewhere in the middle.

Infrastructure, payments, billing, and reliability engineers occupy the extreme end of high retention.
If their work stops, revenue stops.
If they fail, the business fails.

This reveals an important rule:

Retention follows responsibility, not skill level.

AI Products Inherit the Retention of the Jobs They Mimic

Now apply this logic to AI.

Here’s the key insight:

An AI product’s retention mirrors the retention of the human job it replaces or augments.

This explains many current outcomes.

AI tools that generate content, ideas, or demos behave like low-retention creative or prototype roles.
They feel powerful, but users don’t need them every day.

AI systems embedded in finance, operations, sales workflows, or infrastructure behave like high-retention jobs.
They become difficult to remove.

Low retention is not a failure of intelligence.
It is a property of the job.

Why Many AI Products Feel Powerful — But Fade Quickly

There is a useful analogy here.

Many AI products today resemble demo engineers.

They are excellent at:

• producing impressive outputs quickly,
• helping people explore ideas,
• showcasing what’s possible.

But they rarely:

• own long-term responsibility,
• sit inside operational workflows,
• accumulate irreversible history,
• participate in accountability chains.

In real companies, demo engineers are important — but they are not permanent roles.

So when an AI product behaves like one, low retention is not surprising.

This Is Why SaaS Still Wins in the AI Era

This leads to an uncomfortable but powerful conclusion:

AI does not replace SaaS. AI amplifies SaaS.

SaaS systems persist because they hold:

• workflows that cannot stop,
• data that cannot be lost,
• context that accumulates over time,
• responsibility that must be tracked.

CRM systems survive because revenue pipelines must persist.
ERP systems survive because financial history cannot disappear.
Operational tools survive because downtime has real consequences.

Retention comes from the cost of not using the system, not from how smart it feels.

AI Changes Interfaces, Not Retention Physics

As AI models become commoditized:

• intelligence becomes cheaper,
• prompts become interchangeable,
• capabilities converge.

What remains scarce is:

• ownership of workflows,
• historical data,
• organizational context,
• permissions, audits, and compliance.

This creates a clear pattern:

AI kills toy products.
AI strengthens workflow-driven SaaS.

The Winning Shape: SaaS With AI Employees Inside

The future is not “AI replaces software.”

It is software systems where AI acts as a persistent, accountable employee.

Examples are already emerging:

• CRMs with AI sales operators,
• accounting platforms with AI reconciliation,
• ops systems with AI incident responders.

AI becomes a multiplier, not the product itself.

One Final Mental Model

If you remember only one thing, let it be this:

Retention is a function of responsibility.

If users can leave without losing history
and without breaking a process,
retention will always be low — no matter how advanced the AI is.

Final Thought

In the AI era, the best products are not the smartest ones.

They are the ones that carry responsibility.

And that’s why this is my long-term belief:

AI won’t replace SaaS.
It will rewrite every SaaS category from the ground up.

That’s where durable products — and durable companies — will be built.

Why founders, executives, and product leaders are naturally better at “AI programming” than traditional engineers.

Over the past couple of months, I’ve been meeting a lot of founders, executives, and investors.
And something funny keeps happening.

Whenever someone shares a product idea or a workflow, I do one thing:

• I turn on voice capture
• Let AI turn voice to text
• Drop the result into my AI-powered coding workflow
• Generate a working demo in minutes

And people always react the same way:

“Wow, how are you coding so fast?”
“Did your technical ability just level up?”
“Are you becoming a super engineer?”

I always laugh and tell them:

“No. I’m not writing any code.
I’m managing AI.”

01 — My background (so you understand I’m not bluffing)

I’ve never taken a single computer science class in my life.

But over the past decade+, I’ve written more than 10 programming languages:

Java, C#, C/C++, Objective-C++, Python, PHP, JavaScript…

I’ve built:

• Games
• Mobile apps
• Desktop clients
• SaaS platforms

And I also served as a CTO, leading digital transformation for a 30,000-employee organization.

Back then, my mission was simple:

Use software to improve human productivity.

Today, the mission evolved:

Use AI Agents to multiply personal productivity by 10×.

People assume I’m a “hardcore tech guy.”

But today, honestly:

I don’t write code anymore.
I practice Vibe-Driven AI Management.

99.9% of what I build is generated by AI.
And it’s 10× faster than when I wrote code manually.

This sounds crazy.

But it’s simply where the world is moving.

02 — What is Vibe Coding?

Not programming. AI management.**

Vibe Coding is not about writing code.
It’s about expressing a direction — a vibe.

AI does the rest.

Your job becomes:

• Describe the intent
• Define the outcome
• Give the right context
• Break down tasks
• Manage multiple AI tools
• Review, refine, iterate

You’re not “coding.”
You’re:

Leading a virtual team of AI developers who never get tired, never complain, and ship instantly.

Vibe Coding =
Product vision × Communication × AI Management × Decision-making

If traditional coding is “Do it yourself,”
Vibe Coding is:

“Tell AI what you want and manage how it gets done.”

03 — The counter-intuitive truth:

The better the manager, the better they use AI.
The more someone depends on manual coding, the harder AI becomes.**

Why?

Let me tell you a story.

Imagine you take an Uber.
You start enthusiastically talking about how amazing autonomous driving will be.

The driver’s reaction?
Instant frustration.

You’ll hear:

• “Self-driving isn’t as safe as you think!”
• “It can’t handle real road situations!”
• “I’ve been driving for 20 years — I know better!”
• “Machines can’t replace humans!”

You praise tech → he criticizes harder.

Why?

Because self-driving threatens his identity.

Now apply this to AI programming.

If you tell engineers “AI coding is amazing,” you hear:

• “AI code is low quality.”
• “I can do it faster myself.”
• “AI will never replace real engineers.”

Not because AI is bad.
But because their value system is tied to typing code.

Now compare this with founders, PMs, executives:

They don’t have identity risk.
They already:

• Communicate
• Define goals
• Break down tasks
• Manage uncertainty
• Make decisions
• Run teams

So when AI comes along, they instantly see:

AI isn’t “better coding.”
AI is a new kind of workforce.

And they naturally step into the role of AI leader, not coder.

04 — The rise of “PM-powered engineering”

Product managers become 10× creators with AI**

This is one of the most underrated shifts in tech.

Before (old world):

PM → writes spec → begs engineers → waits weeks.

Now (AI world):

PM → describes vibe & logic → AI builds it → PM reviews → ship

Their skill set is PERFECTLY aligned with AI:

✔ They communicate clearly
✔ They think in systems
✔ They break down flows
✔ They understand the user
✔ They know what “good” looks like
✔ They give focused feedback
✔ They care about delivery

They were previously “support role.”
Now they are:

AI Team Leads.

05 — Vibe Coding = Expression × Management × Judgment

AI doesn’t need your hands.
It needs your head.

AI needs:

• Clear intent
• High-resolution instructions
• Context
• Constraints
• Quality expectations
• Fast iteration

If you can express your idea well,
AI can:

• write the code
• generate the UI
• design the UX
• write the docs
• build backend logic
• troubleshoot errors
• deploy the app

Your role becomes:

Vision, orchestration, leadership.
(Not typing.)

06 — The new productivity formula

Traditional productivity:

People × Time = Output

AI Productivity:

(Your management skill) × (Number of AI tools you can coordinate) = 10× Output

In the past, a 10-person team built a product.
Today, one person can do it — if they can manage AI.

You didn’t become 10 people.
You learned to lead 10 AIs.

The future “elite builders” aren’t super coders.

They are:

Super managers of AI labor.

Conclusion

The strongest creators of the AI era won’t be engineers.
They will be AI managers.

Vibe Coding is not “AI-assisted programming.”
It’s a new way of working.

You’re not coding.
You’re managing a full AI workforce.

The people who will benefit the most:

1. Founders
2. Executives
3. Product managers
4. Team leaders
5. Anyone who can communicate and make decisions

AI is the most reliable “employee” you will ever have.
And your only job?

Lead it.

If you’ve tried building an “AI agent” recently, you’ve probably experienced the same frustration many developers now share:

Everything looks magical in diagrams.
Everything becomes chaotic the moment you run a real benchmark.

And nothing exposes the chaos faster than GAIA Benchmark — an evaluation that forces your agent to plan, search, browse, compute, reason, verify, and synthesize across multiple modalities, sometimes at a difficulty level close to human exams.

The surprising truth?

Most agent frameworks today are not actually designed to win GAIA.
They’re designed to demo nicely.

That’s why GAIA Super Agent SDK exists.

GitHub → https://github.com/gaia-agent/gaia-agent
NPM → @gaia-agent/sdk

This article is not a tutorial.
It’s the story of why this SDK matters, what makes it different, and how it can shift the emerging world of agent development.

The Problem: Current Agent Frameworks Are Too Expensive (in Time)

Agent frameworks today often demand one of two extremes:

1. Heavy abstractions

Graph editors. JSON blueprints. Agent DSLs.
All powerful, none practical for fast iteration.

2. “Bring your own everything”

You want browser automation? Add 300 lines.
You want code execution? Add a sandbox provider.
You want GAIA-level reasoning? Good luck convincing the LLM to obey.

The GAIA benchmark especially hurts because it requires:

• deep tool integration
• reproducible results
• long-horizon planning
• reflection & verification
• browser + search + code execution
• multi-step agent loops
• predictable logs

Most frameworks don’t solve these problems.
They transfer them to you.

So the question becomes:

What would a GAIA-ready, production-usable agent look like if someone actually built the whole thing end-to-end?

The Answer: GAIA Super Agent SDK

The core idea of the project is refreshingly simple:

Ship a fully wired “Super Agent” that can immediately tackle GAIA tasks without extra infrastructure.

It’s built on top of:

• AI SDK v6 ToolLoopAgent (the new “standard loop” in the ai SDK ecosystem)
• ToolSDK.ai for pulling additional tools
• A ReAct + Planning + Verification loop

This combination isn’t random — it’s exactly what competitive GAIA submissions gravitate toward.

What you get out of the box:

• ReAct-style reasoning
• Multi-step planning
• A verification layer
• Browser, search, code execution, memory
• 18+ tools pre-integrated
• Parent tracing & debug-friendly logs
• One-line agent instantiation
• Configurable providers (Tavily → Exa, Steel → BrowserUse, E2B → Sandock…)

Not a “framework.”
A finished agent, ready to evolve.

Why GAIA Benchmark Is the Perfect Stress Test

AGI researchers often call GAIA the closest thing we have to a real-world reasoning exam.

And it’s true.

A good GAIA agent must be able to:

• read unfamiliar instructions
• design a plan
• search for accurate information
• open a browser and interact with a website
• use mathematical or code tools
• verify whether the answer makes sense
• handle multi-hop dependencies

Unlike synthetic tasks, GAIA forces your agent to perform coherent, end-to-end cognition.

So here’s the philosophical point:

If an agent can perform well on GAIA, it’s probably capable of solving real user tasks.

This is why GAIA Super Agent SDK is not just a benchmark tool — 
it’s a blueprint for real agentic product builds.

The Most Underrated Feature: Iteration on “Wrong Answers”

One of my favorite ideas in the SDK is the wrong-answer pipeline.

When you run:

pnpm benchmark

Every incorrect case goes into:

benchmark-results/wrong-answers.json

Then you refine your agent, and rerun only the failures:

pnpm benchmark:wrong --verbose

This transforms GAIA into a training ground, not a scoreboard.

You don’t fear failure.
You exploit it.

Providers as LEGO Blocks (Not Dependencies)

Most agent frameworks lock you into one choice:

• This search provider
• This browser
• This sandbox
• This memory backend

GAIA Super Agent SDK does the opposite.
Everything is swappable by:

• One line of code
• Or one environment variable

Example:

createGaiaAgent({
  providers: {
    search: 'exa',
    browser: 'browseruse',
    sandbox: 'sandock'
  }
})

This makes experimentation fast, which is the entire point of agent work.

And Yes — It’s TypeScript-First

This might sound trivial, but for many developers building modern AI products, TypeScript is a first-class requirement.

The SDK is:

• strict typed
• ESM
• tree-shakable
• editor-friendly
• built with Vitest-driven CI
• published via automated workflows

It feels like a library meant to be used daily, not a research artifact that eventually rots.

A Quick Demo: What It’s Like to Use

import { createGaiaAgent } from '@gaia-agent/sdk';

const agent = createGaiaAgent();

const result = await agent.generate({
  prompt: 'Compare the growth of AI research publications from 2021–2024.',
});

console.log(result.text);

That’s all.
The agent will:

• search
• plan
• fetch content
• run calculations
• verify the answer
• return a final structured response

All without you wiring tools manually.

Why This SDK Matters Now

We’re hitting a turning point:

• LLMs are getting stronger
• Agents are becoming real
• User workflows are increasingly multi-step
• Benchmarks reflect real-world tasks
• Developers want production-ready tools, not demos

GAIA Super Agent SDK is part of a broader shift:

Agents are becoming software — not prompts.

And like any great software, we need:

• strong defaults
• clear abstractions
• predictable performance
• extensible architecture
• testing & benchmarking
• minimal boilerplate

This SDK checks these boxes unusually well.

Final Thoughts

If you’re building:

• a capable personal or business assistant
• an autonomous agent for real workflows
• a GAIA benchmark runner
• or simply experimenting with multi-tool reasoning

This project is worth exploring.

It represents a pragmatic approach to agent development:

• not hype
• not theory
• not “build your own framework”
• but a ready-to-run, production-minded super agent

Give it a try:
👉 https://github.com/gaia-agent/gaia-agent

If you write an evaluation, run a benchmark, or build something on top — 
share it. The agent ecosystem needs more real-world experiments.

🧠 TL;DR

Just as 20th-century workers were divided into blue-, white-, and gold-collar roles, 21st-century AI agents are forming their own labor hierarchy — builders, thinkers, operators, specialists, guardians, and auditors.
This essay proposes a founder-friendly framework for organizing your AI workforce by collar color, helping startups design smarter, more defensible product stacks.

1. From Human Collars to AI Collars

For more than a century, humans have been sorted by the color of their collars.
White-collar workers ran offices. Blue-collar workers built the world. Pink, gold, green, and gray added nuance for service, expertise, sustainability, and hybrid roles.

Each color represented a role in the economy — an easy visual shorthand for what kind of work someone did.

Now, as AI agents begin to replace or augment those roles, the same classification quietly reappears. Some agents write and plan, others sell and execute, others monitor and repair. We are witnessing the birth of a synthetic workforce that mirrors human labor — one line of code at a time.

For founders, this isn’t philosophy.
It’s a design pattern for building companies where AI is the team.

2. The New Spectrum of Machine Labor

In the emerging AI economy, every agent fits somewhere on a spectrum that echoes human labor:

• White-collar AIs handle office work — writing, planning, summarizing, designing. They are the Notion AIs, the Jaspers, the SlidesGPTs of the world. Easy to build, brutally competitive.
• Blue-collar AIs form the backbone — infrastructure, sandboxes, search indexes, and cloud runtimes. They are unseen but essential. Building them takes capital and deep engineering, but they offer lasting moats.
• Gray-collar AIs handle operations and communication: AI SDRs, CRM copilots, field assistants. They sell, negotiate, and follow up like tireless employees.
• Gold-collar AIs are specialists — expert coders, lawyers, doctors, or analysts. They command trust, not volume.
• Pink-collar AIs build relationships — companions, social assistants, and empathetic bots like Pi.ai or Replika.
• Black-collar AIs guard the system — scanning for anomalies, enforcing compliance, and protecting data.
• Silver-collar AIs test, evaluate, and audit others. They’re the quality controllers of the agent ecosystem, ensuring reliability and safety.

Even the AI Pins and note-taking devices — like Rabbit R2, Limitless, or CusPin.ai (AI NotePin) — can be viewed as gray-collar devices: operational tools that bridge the human world and the AI cloud.

3. Why This Framework Matters for Founders

Most founders today build in white-collar territory — productivity, writing, and marketing copilots. It’s familiar, fast, and crowded.
But the deeper collars — blue, black, and silver — are where the moats form.

Thinking in collar colors helps you:

• Clarify your company’s position in the AI workforce. Are you hiring thinkers, builders, or guards?
• Identify competition intensity. White-collar AIs fight in red oceans; blue-collar and silver-collar spaces remain underexplored.
• Plan organizational design. Treat each collar as a department in your digital company: infrastructure, sales, security, QA, companionship, and expertise.
• Allocate resources strategically. Outsource the non-core collars, and invest in the ones that define your unique advantage.

Once you view your agents as workers — each with a collar and a role — you stop building features and start designing workforces.

4. The Coming Age of AI Workforce Design

The next generation of startups won’t just write prompts — they’ll hire, train, and manage diverse collars of AI labor.
A small human team might coordinate dozens of synthetic workers:
white-collar content agents, gray-collar outreach bots, blue-collar infra agents, and silver-collar evaluators.

In this model, founders become workforce architects.
They’ll decide which collars to build in-house, which to rent from platforms, and how to make them collaborate.

Over time, this will give rise to AI org charts, agent departments, and synthetic HR systems.
The “future of work” won’t be human vs. AI — it’ll be humans managing AI teams across multiple collars of intelligence.

5. The Founder’s Reflection

When you stop seeing AI as a feature and start seeing it as a workforce, the strategy shifts completely.

You begin asking: What type of labor am I automating? What color is my AI team?

Some agents will think, some will build, some will sell, some will defend.
Your success depends on how well you orchestrate them together.

The designation of AI agents by collar color is not just a metaphor — it’s a blueprint.
It helps founders structure the next industrial age: one where cognition, code, and collaboration merge into a single, intelligent organization.

🪙 Author Note

This framework was inspired by the historical classification of human labor and reimagined for the emerging agentic AI economy — where startups no longer hire people to scale, but collars of machines.

🚀 Introduction: The End of the “Build It and They Will Come” Era

For more than a decade, the startup playbook was simple: build a great product, run ads, and wait for growth.
But in 2025, that model no longer works.

Even the best AI-native products fail without a modern GTM (Go-to-Market) strategy — one built on loops, communities, and compounding trust, not just funnels and features.

Across hundreds of AI startups in the U.S., Europe, and Asia, the same pattern has emerged:

The companies that win aren’t those with the most features, but those with the most adaptive growth systems.

This article breaks down the new rules of GTM growth — based on real patterns from AI companies scaling globally — and how founders can apply them today.

🧩 1. From Funnels to Flywheels: The Shift to Growth Loops

In the past, growth followed a linear path:
awareness → lead → conversion.

Today, the best startups run on circular growth loops — where every user action generates new users or content.

• Old Model: linear funnels, performance marketing, paid social.
• New Model: feedback loops, user-generated content, AI-driven virality.

Each interaction compounds: one engaged user creates the next one.

Descript, Notion, and Midjourney all scaled through loop mechanics — not ads.
They built systems where product usage creates marketing.

🎯 2. Messaging That Converts: From “What It Does” to “Who You Become”

Traditional marketing emphasized features — “What does the product do?”
Modern GTM emphasizes identity — “Who do I become when I use this?”

Emotion-led, outcome-based messaging outperforms feature lists because people buy stories, not specs.

Old: “AI tool that automates workflows.”
New: “Your 24/7 copilot that makes work feel effortless.”

The best brands sell transformation, not technology.

🌱 3. Community Is the New Growth Engine

In the AI era, community is not a nice-to-have — it’s your core GTM asset.
A strong community creates retention, trust, and product feedback loops.

• Build owned channels: Discords, newsletters, and private beta groups.
• Reward advocacy: templates, showcases, affiliate loops.
• Enable creation: let users remix and share your product outputs.

Figma, Canva, and Replit grew not by buying users — but by building tribes that turned users into evangelists.

🔁 4. Design Growth Loops, Not One-Off Campaigns

Campaigns end. Loops compound.

Every GTM initiative should either:

1. Create new users,
2. Inspire users to create content, or
3. Improve the product through usage.

If it does none of those, it’s a vanity play.

Templates, public showcases, and marketplaces (like Canva’s template hub or Descript’s gallery) reduce friction, speed up onboarding, and drive self-reinforcing adoption.

💬 5. Channels Have a Half-Life — Adapt or Die

What worked last quarter might flop next quarter.
Treat every growth channel as perishable.

AI-generated SEO pages that ranked last month may now be penalized.
The winners combine E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) with authentic distribution — across LinkedIn, Substack, Reddit, and niche communities.

Consistency builds authority. Authenticity builds trust.

Instead of chasing hacks, compound your presence through credible, human-authored insights.

📈 6. Measure Compounding, Not Conversions

The best GTM teams track loop velocity, retention curves, and content amplification — not just CAC and ROAS.

They ask:

• How fast does one user lead to the next?
• How much new reach does each piece of content generate?
• How deeply is our brand remembered after a touchpoint?

These metrics capture momentum, not just motion.

🌏 7. For Global Founders: Start Small, Build Local, Then Scale

For Chinese and Asian B2B founders expanding abroad, the key is local learning loops.

• Build local sales relationships early — referrals matter.
• Attend industry-specific events instead of broad expos.
• Hire generalists first who can wear multiple hats, then specialize later.

International expansion rewards patience, proximity, and persistence — not blitzscaling.

⚙️ 8. Build an Experimental Metabolism

Growth isn’t a plan. It’s a habit.
Run small, constant experiments: new surfaces, new stories, new audiences.

Kill what doesn’t work fast.
Double down on what compounds.

As the environment changes (short-form video, AI search, agents), your agility becomes your advantage.

🧠 Key Takeaway: Stop Chasing Growth. Start Owning Gravity.

Most teams over-invest in visible growth — ads, posts, SEO — and under-invest in invisible growth:
community, brand, and product learning rate.

But invisible growth compounds — making every future campaign cheaper, faster, and more trusted.

Amazing products attract attention.
Compounding systems sustain it.

🔎 About the Author

Follow me on X: https://x.com/kellypeilinchan

AI can build your website.
But only you can make it breathe.

The New Creative Language Between Humans and AI

Vibe Coding Design isn’t just about generating code.
It’s about directing emotion through language.

When you talk to an AI coding assistant — whether it’s ChatGPT, Cursor, or Figma AI — 
you’re not just describing a layout.
You’re describing a feeling.

You’re saying:

“I want this page to feel cinematic. Slow. Confident. Like Apple.com on a quiet morning.”

That’s Vibe Coding Design.
It’s the art of translating human rhythm into machine-readable design.

The Problem: AI Has No Taste (Until You Give It One)

AI can build grids, align buttons, and select colors that technically work.
But it has no idea what beautiful feels like.

That’s your role.
You are not just coding.
You’re directing.

You give AI its sense of timing, its breath, its tone.
And the more precisely you describe those, the more your design comes alive.

Stop Prompting Like a Developer. Start Directing Like a Filmmaker.

A developer says:

“Create a modern landing page with three sections.”

A director says:

“Build a page that feels calm and cinematic.
The hero fades in slowly.
Text appears in rhythm, not all at once.
The light flows from top right.
The button feels like an invitation, not a command.”

See the difference?
One gives structure.
The other gives life.

The Three Layers of Beautiful Vibe Coding Design

Every great AI-generated interface has three emotional layers.

Scene — What does this moment feel like for the user?
A welcome? A discovery? A decision?

Visual — What does the user see?
Light, depth, spacing, rhythm.

Motion — How does the screen move?
Fade-in speed, hover lift, timing, easing.

When you describe these three layers, your AI stops generating templates
and starts generating experience.

Geometry and Silence

In vibe coding, silence is part of the design.

Whitespace is not empty — it’s breathing room.
Typography is not text — it’s rhythm.
Timing is not animation — it’s tone.

Small rules that always work:

• Let the layout breathe: 30–50% whitespace.
• Keep line length between 60–70 characters.
• Use low-saturation colors — no pure black or white.
• Animate gently: 200–300 ms is enough.
• Never animate everything. Animate meaning.

The best websites feel like a pause between sentences.

Teach AI the Language of Aesthetics

AI doesn’t understand “beautiful.”
It understands relationships — between light, distance, time, and hierarchy.

Instead of saying “make it premium,” say this:

“Centered layout, soft gradient, deep contrast, slow fade-in.”

Instead of “make it minimal,” say:

“Single column, 40% whitespace, muted palette, no borders.”

You’re not asking AI to guess your taste.
You’re teaching it your grammar of beauty.

Motion as Emotion

In vibe coding, motion is not decoration — it’s psychology.

Fast transitions create excitement.
Slow transitions create calm.
Delay builds rhythm.

Simple benchmarks that feel right:

• Micro-interaction: 120–180 ms
• Page transition: 220–300 ms
• Hover feedback: lift 2 px, brighten 10%
• Staggered content: 40–80 ms delay per element

Good motion is invisible.
Bad motion screams.

Write Your Own “Aesthetic Vocabulary”

Every great vibe coder collects words for feelings.
Not adjectives — images.

Start building your list. Examples:

• “Soft Nordic light with air between elements.”
• “Cinematic calm — product as protagonist.”
• “Tokyo tech — glass blur, chrome reflection, gentle motion.”
• “Editorial warmth — serif headlines, off-white paper tone.”

This is your creative language.
Feed it into prompts.
AI will begin to recognize your style — like a fingerprint.

Design as Storytelling

Every good interface tells a story.

Think of your site as a short film with five acts:

Act 1 — The Entrance
The calm first impression.

Act 2 — The Choice
A single clear action.

Act 3 — The Reveal
Light shifts, content unfolds.

Act 4 — The Action
One decisive interaction.

Act 5 — The Afterglow
A quiet, satisfying completion.

If you describe your UX like a story, AI designs your narrative.
You don’t get pages — you get scenes.

Training Your Eye (and Your Language)

To improve as a vibe coder, practice this every day.

1. Open a site you love — Apple, Notion, Linear, Vercel.
2. Watch it for 30 seconds.
3. Write five sentences:

• What emotion does it create?
• How does it use space?
• What is the light doing?
• How does it move?
• Why does it feel calm or powerful?

This is how you train your perception muscle.
Design starts in your eyes, but it’s expressed in words.

The Framework You Can Reuse

When you work with AI, structure your prompts like this:

🎯 Goal:
Design a [page/component] that feels [emotion].

🎨 Visual:
Describe layout, light, color tone, and typography rhythm.

⚡ Motion:
Define timing (120–300 ms), easing (ease-out/spring), delay (40 ms).

🪶 Material:
Mention texture, depth, or blur.

💬 Emotion:
Use sensory words — calm, cinematic, confident, intimate.

That’s your blueprint for every design conversation with AI.

The Future of Frontend Is Emotional

AI has mastered code, layout, and pattern.
But it still can’t feel.

That’s where humans come in.
We bring emotional precision.
We turn structure into story.

Vibe Coding is not about removing humans — it’s about amplifying them.
You describe the feeling.
AI paints the frame.

Together, you make something alive.

“Coding built the web.
Vibe Coding will make it beautiful.”

1. Most Software Was Never Truly Built for Humans

Not long ago, we bought a slick new expense management tool for our company — a modern SaaS platform with every feature imaginable. I asked one of our newer employees to file a simple reimbursement.

He hesitated.

“Where do I even start?” he asked, staring at a screen full of menus, buttons, and dropdowns.

This wasn’t his fault. It’s not a training issue. This is what enterprise software does to people. It overwhelms. It alienates.

And the worst part? It was supposedly “user-friendly.”

The uncomfortable truth is: software has never truly been “human-centric.” It was built for a time when humans had no choice but to operate machines manually — because machines couldn’t understand us.

2. The End of the Human-as-Operator Era

Before large language models, all software assumed one thing: a human must sit at the controls.

Everything — from accounting apps to CRMs — was built around inputs, buttons, and workflows designed for human execution. Software was a giant panel of toggles, menus, and sequences that only made sense once you memorized the manual.

But now? The paradigm is shifting.

AI can understand goals. It can interpret language, plan actions, and even execute them autonomously.

In this new world, the role of software changes. It’s no longer about “teaching the human how to operate the machine.” It’s about giving the AI the tools to act on our behalf — securely, intelligently, and efficiently.

3. Humans Were Never That Good at Software Anyway

Let’s be honest: most people don’t enjoy using enterprise software. It’s unintuitive, bloated, and riddled with complexity. People spend hours in onboarding sessions, click the wrong thing, and give up.

This isn’t because users are lazy. It’s because most software was designed with the wrong assumption: that people want to think like software systems.

They don’t.

Ironically, the most loved “software” in the workplace is Excel — a wildly unstructured, freeform sandbox that breaks every rule of modern UX. But people love it because it bends to their needs.

People want flexibility. Software wants structure.

This mismatch is precisely where AI shines: bridging human ambiguity with machine precision.

4. Every Software Needs to Be Rebuilt

If legacy software was designed under the assumption of human operators, and now we live in a world where AI can be the operator…

Then the conclusion is clear:

Every software product — yes, every one — is up for reinvention.

• Email? AI can triage, summarize, and respond.
• CRMs? AI can manage leads and follow-ups.
• Finance? AI can reconcile, generate reports, and flag anomalies.
• HR? AI can screen resumes, schedule interviews, and respond to candidates.

This is not a cosmetic update. It’s a wholesale design reset.

Some incumbents will adapt. Most won’t.

This is the biggest entrepreneurial opportunity of the decade — and also its biggest threat.

5. The New Paradigm: Software as AI’s Interface, Humans as Controllers

As we shift from “human-centric” to “AI-native” software, one assumption needs to be re-examined:

Will UI become less important?

Actually — no. UI will become more important than ever. But it won’t look like what we’re used to.

In the past, the UI was there to tell humans what to do. In the AI-native world, the UI becomes a real-time, adaptive cockpit — a human control layer over autonomous systems.

Think Iron Man and Jarvis.

Jarvis doesn’t show Tony Stark a spreadsheet. He builds holographic interfaces on the fly, tailored to the situation. The human remains in control — but the system acts proactively, dynamically, and contextually.

This is the future of UI:

• Dynamically generated.
• Context-aware.
• Controllable, auditable, interruptible.
• Designed for decision-making, not operation.

UI isn’t going away. It’s evolving from a steering wheel to a mission dashboard — something that lets you monitor, approve, and fine-tune what the AI is doing on your behalf.

The software becomes your AI-powered co-pilot. You give it goals. It suggests actions. You approve, adjust, or reject — not unlike how a CEO interacts with a chief of staff.

6. The Great Rewrite

Every product team now faces a fundamental question:

Are you building software for humans to operate?
Or are you building software for AI to operate — with humans in control?

If it’s the former, your product may survive the next 2–3 years.

If it’s the latter, you might be building the next category leader.

Because here’s the truth: the most valuable software companies of the next decade won’t be those with the best UI, or even the most features.

They’ll be the ones who understand this:

In the age of AI, software is no longer a tool.
It’s a partner.

And the job of the designer is no longer to design workflows — but to design control loops between AI autonomy and human intent.

Final Thought

We’re entering a future where:

• Humans define outcomes.
• AI handles execution.
• UI serves as a control panel, not a button board.

So maybe it’s time to stop asking:
“How can I make my software easier for users to click?”

And start asking:
“How can I make my software easier for AI to act — and for humans to trust?”

Because that’s the real design challenge of this decade.

🔁 For me, it’s time to stop designing software for humans.
🧠 Start designing software for AI — and let humans finally focus on what they’re best at: creativity, judgment, and vision.

A few days ago, OpenAI dropped a bombshell:
it quietly unveiled Agent Builder and AgentKit, a full-stack way for anyone — yes, anyone — to create, run, and deploy their own AI agents inside ChatGPT.

It’s not just another feature.
It’s a paradigm shift — one that could erase entire categories of startups overnight.

If you’ve raised millions to build an “AI agent platform,”
you might want to check your runway again.

1. The Real Meaning of Agent Builder

For the past two years, the AI ecosystem has been full of startups promising one thing:

“Build your own AI agent without code.”

They built beautiful dashboards, visual editors, and “digital employee” metaphors — pitching to founders, marketers, or ops teams who didn’t want to deal with APIs or fine-tuning.

OpenAI just made that promise native to ChatGPT itself.
You can now design, store, and deploy agents directly inside the world’s most popular AI platform — backed by GPT-4, memory, and tool use.

This isn’t a feature update.
This is vertical integration.

2. The First Casualties

The first startups to feel the quake are those whose entire product pitch sounds like this:

• “No-code AI agent builder.”
• “Manage your AI team from one dashboard.”
• “Drag and drop workflows for GPT agents.”
• “AI employees for your sales or customer support.”

Let’s call them Company A, Company B, and Company C.
You probably know who they are.

Company A spent the last year building a stunning visual studio for creating agents with memories and functions.
Company B built “AI employees” for go-to-market teams — complete with CRM and Slack integrations.
Company C positioned itself as an “agent ops layer” offering monitoring, permissions, and analytics.

All of them just woke up to the same reality:
OpenAI now does 80% of what they do — natively, securely, and for free.

3. Why Their Moats Just Vanished

There are four brutal reasons these startups are in trouble.

1. Infrastructure Compression.
When the platform provider integrates the entire stack — model, runtime, orchestration, deployment — there’s little room left for “platforms on top of the platform.”

2. Network Effects.
Tens of millions of users already live inside ChatGPT. Once Agent Builder becomes a default capability, the gravity of that ecosystem will suck in the long tail of potential customers.

3. Speed Asymmetry.
A startup shipping monthly can’t compete with a company that updates the world’s most used AI product every week.

4. Trust & Compliance.
Enterprise buyers will naturally prefer “agents inside ChatGPT” over “agents on a startup’s website.” The perception of reliability alone kills half the sales cycle.

4. Not Everyone Has to Die

Still, not every company in the agent space is doomed.
A few categories have real survival chances — if they move fast.

1. Vertical Specialists.
Teams that embed AI deeply into one regulated or data-heavy domain — like finance, healthcare, legal, or manufacturing — can still win.
OpenAI won’t tailor solutions for those micro-niches anytime soon.

2. Ecosystem Builders.
Startups that shift from “competing with” OpenAI to “building on” OpenAI — providing plugins, connectors, or domain-specific agents — can thrive as part of the new ecosystem.

3. Experience Innovators.
User experience remains an open frontier.
Whoever builds the most human, visual, or workflow-integrated layer on top of AgentKit will own the user relationship — even if OpenAI owns the infrastructure.

In short:
Don’t build another Agent Builder.
Build on the Agent Builder.

5. The Hard Questions Every Founder Must Ask

1. Is your differentiation still real?
   If your core pitch is “we make GPT easier to use,” you’re already obsolete.
2. Are you a platform or a plugin?
   In the new hierarchy, only the base platforms and the apps built on them will survive.
   Middle layers get squeezed out.
3. What’s your moat — truly?
   If your moat depends on model capabilities, it’s not yours.
   If it depends on proprietary data, brand, or community, you still have a shot.

6. The Broader Shift: From Decentralization to Centralization

The launch of Agent Builder marks a pivot in the AI industry’s power dynamics.
For two years, innovation was decentralized — thousands of small teams built wrappers, toolkits, and platforms around OpenAI’s APIs.

Now, OpenAI is consolidating that creativity back under its own roof.
It’s not evil; it’s economics.
Every mature platform eventually absorbs its most successful extensions.

This is the same story we saw when Apple launched the App Store.
It democratized app creation — and simultaneously destroyed hundreds of software distributors overnight.

7. The Coming Year: Who Lives, Who Dies, Who Adapts

In the next twelve months, expect to see:

• Dozens of “AI agent builder” startups quietly pivot, merge, or shut down.
• A few strong teams rebrand themselves as “AgentKit Partners” or “OpenAI Integrators.”
• Enterprise buyers consolidating vendor lists — preferring official OpenAI tools over third-party platforms.
• A new wave of micro-founders building specialized agents inside ChatGPT, not outside it.

The energy won’t disappear — it’ll just flow downstream.

8. Final Thoughts

OpenAI didn’t need to kill these startups.
It only needed to make them redundant.

The age of “agent builders” is ending.
The age of “agent ecosystems” is beginning.

For founders, the message is clear:

Survive by specializing.
Thrive by integrating.
Die by competing head-on with your platform.