The Battlefield Moved

The battlefield moved from chat to finished work. For a year the field chased chatbots. An agent books the trip, files the forms, runs the store, and finishes the job. It asks you only when a human must decide.

Sam Altman speaks about an agent store. Platforms build stores for the thing they expect people to buy.

If you start a product now, the obvious move is to clone the assistant. Build what everyone else builds and the best people go elsewhere, and the large companies win on distribution. Aim instead at the idea that sounds a little crazy today and turns obvious once it works.

The largest opening sits in plain sight. Models already do far more than the products around them show. Closing that distance needs a product, and it does not need a new model.

Two ways to win, and only one is for sale

You can win in AI in two ways. Brute force buys more data, more chips, and longer training runs, and the frontier models arrived that way. Insight is the second way, where one design change beats raw size by a hundred times.

John Jumper puts the trade in three words: data, compute, ideas. Anyone with money buys the first two. The third one multiplies whatever the first two bought.

Know which path you are on. If you do not train foundation models, say so and build the product layer. That layer is the workflow, the trust, the interfaces, the guardrails, and the distribution. Put a human in the loop wherever the decision is real.

The narrow tool is the position worth holding. A tool pointed at one job for years becomes the thing the platform sends traffic to. That is one protected direction again, held by a company instead of a person. A clone spends those same years on ground OpenAI already owns, with less compute and less distribution.

The moat forms after you ship. A new field cannot price quality yet. Buyers cannot separate a working agent from a demo, so they follow the signal that travels, the name they heard from someone they trust. Once the market learns to measure the work, the tool that measures well keeps the traffic.

The founder shape follows from that. Keep a stubborn belief in the goal and a small ego about the path. Talk to users, and accept that you look wrong for a long time.

Two and a half thousand builders, one message

Y Combinator ran the camp over two days for young builders. One message ran through every talk, every hallway chat, and every half-finished notebook demo. If you are hungry and curious, start the company now. The cost of a try is low, and a failure still teaches you faster than any other path.

Aim high and stay concrete. Keep the ambition large, take small steps, and run fast loops. Code keeps stretching under these models, so an idea that felt too large last year can be easy next year.

Pick problems that are still rough. Use the tools that break. Put AI where the work feels awkward and brittle, because that is where the sharp edge shows up early. Then look for the place where adoption jumps once one switch flips.

The hall in San Francisco was packed and nobody in it was waiting for permission. I visited Anthropic and came away with Claude credits, and an AWS party handed out cloud credits like candy. I found other Amherst alums and we traded notes late into the night. I left with a notebook full of ideas and the itch to start building the next morning.

What the builders said

Sam Altman

OpenAI started with eight people and a guess that AGI mattered. It had no plan and no revenue, and belief was the only asset. That kind of belief attracts talent with nowhere else to go.

The name for the gap is his: the product overhang. His own next step is memory, an assistant that knows you well enough to help before you ask without turning creepy. It runs in the background, connects to your data, and works like a junior colleague.

On people, he looks for smart and driven builders who finish things and work well with others. Judge them by what they made. Choose slope over the starting point, because a person who improves fast passes a polished slow one.

Conviction is the hard part. Elon once wrote to him that OpenAI had a zero percent chance. That hurts, and you continue. It gets easier after each hit and it never gets easy.

Satya Nadella

Nadella called AI the fourth platform shift after client-server, the web, and mobile. He put the limit on habits rather than chips. Drop an agent into a messy workflow and the workflow stays messy. You have to redraw it first.

He named three pieces that are still missing: memory, safe tool use, and permission systems. Build those and the assistant becomes reliable instead of a loose cannon.

Trust rests on three fronts: privacy for users, security for firms, and sovereignty for nations. Ignore one and adoption stops.

AI will demand much more energy, and the world grants that energy only when the value is plain. Most knowledge work still runs on copy-paste, approvals, and invisible busywork. Build the tool that removes the drudgery and shows the gain.

Andrej Karpathy

Karpathy's talk is the one I replayed most. Software has three chapters. People wrote exact instructions. Then we trained on piles of data and the rules became weights. Now large models act like a new kind of computer, and we program them in plain language.

A prompt is a program. English is a coding language. Anyone who writes a clear sentence can make software. Karpathy built a simple iPhone app in a day without knowing Swift. I vibe-coded this site in two days on limited JavaScript, and the code was the easy part. The setup and the deployment took the time.

He compared the era to the 1960s. Mainframes sat in locked rooms and people reached them through time-sharing terminals. Large models now sit in cloud data centers and we send prompts over the net. When a service goes down we feel an overall intelligence drop, and the planet gets a little less smart until it returns.

Then he cooled the autonomy demos. He rode in a Waymo in 2013 that drove perfectly for thirty minutes, and twelve years later engineers still tune self-driving systems. Agents will work like an Iron Man suit. The human holds control first, and autonomy arrives one safe step at a time.

So the products that work today aim at partial autonomy. Cursor does coding and Perplexity does research, and both do the same four jobs. They gather the right context, call several models, show the result in a simple interface, and hand you an autonomy slider. You check the work with diffs or cited sources.

He rates speed in the loop above raw model IQ. A two-line change you can scan beats a large block you have to read slowly. Keep the model on a short leash, check the result fast, then ask for the next step.

He also wants software that models can read. Put a plain llm.txt at the top of a project. Write docs in simple markdown with curl examples instead of click paths. Some tools digest a repo into one text blob or summarize a codebase, and that saves time for people and for models. Track how much old code each replacement removes, because deleted code is a progress metric.

Andrew Ng

Ng stayed on the ground where founders live. Speed decides life or death, so learn the tools that make you faster. The money sits in the apps people open every day.

He pushed agentic AI as the next step. The agent is a loop that plans, searches, drafts, checks, and fixes. That loop needs glue above it, a layer that calls many models and tools. The glue makes an AI app about as easy to write as a web page in 1999.

He kept pulling founders back to clarity. AI for health care is fog. Let patients book MRI time online is specific. Specific ideas let teams move.

He drew a hard line between prototypes and production. Prototypes run about ten times faster now. Production code runs about twice as fast. Write ugly code on your laptop first, then make it safe when you ship.

His feedback ladder is cheap and ordered. Use the product yourself, then ask three friends, then ask strangers in a coffee shop, then send it to a hundred testers. Run the large A/B tests last. Study what happened after each round and sharpen your instinct.

He called the parts Lego bricks: prompts, evals, guardrails, RAG, voice, embeddings. Every brick you learn lets you build more. Ignore token bills at the start, because the day you have to optimize them is the day you already won. Write the code so you can swap models, run evals every week, and move to the best one.

Domain skill still decides quality. An art student writes better image prompts, and a doctor guides a triage bot better than either of us. Build something users love first, because momentum is hard to copy.

François Chollet

Chollet went further than anyone else on the stage. Larger models will not give us machines that think. Compute got cheap, deep learning grew fast once GPUs were cheap and data was plentiful, and large models got good at set tasks.

The field then borrowed one belief from that curve: scale alone produces general intelligence. He says the borrowed belief is wrong. Large language models mostly replay skills from training, and intelligence handles a problem it never saw.

He built ARC to show the gap, and humans solve it easily. Scaled-up language models stay near zero unless they learn during the test. Last year researchers let models change themselves at run time. The models fine-tuned on the task, wrote small programs, and revised their own thoughts mid-problem. Scores rose and still lag humans. Pre-training is not enough, and a model has to adapt at test time.

He put two definitions of AGI side by side. Minsky said a machine that does most jobs people do. McCarthy said a machine that solves new problems without help. The second is harder and more useful. Skill is the product, and intelligence is the factory that makes new skills.

His picture of the world is close to poetry. Endless variety comes out of patterns that repeat, like a kaleidoscope. To be smart is to find those patterns and reuse them fast.

He splits patterns in two. Type 1 patterns are fuzzy, like seeing that one tree resembles another, and deep nets handle them well. Type 2 patterns are exact, like seeing that two pieces of code do the same thing, and deep nets struggle where people reason easily.

Search over programs finds type 2 ideas, and brute-force search explodes. The trick is to steer the search with type 1 intuition so it opens only the branches that can work.

He described a system that works like a hacker. A new task arrives, the system pulls blocks from a library that keeps growing, then wires and adjusts them until the test passes. Each success adds blocks and sharpens its hunches, so the next task costs less.

His lab, Ndea, bets that this mix of learning and search speeds up science. The first milestone is to beat ARC from scratch with a self-improving programmer. One line of his stayed with me. Scaling automates the past, and to invent the future a model has to write new code while it runs.

John Jumper

Jumper gave the clearest lesson in trading hardware for ideas. His goal was always to shorten the time between an idea and the proof of it.

Proteins are the small machines that run every cell. DNA lists their parts like beads on a string, and the string folds into a gadget that works. Finding one shape used to take a year, a crystal the size of dust, and about a hundred thousand dollars. DNA sequences piled up three thousand times faster than structures, so the backlog kept growing.

At DeepMind he read AlphaFold through the same three words. Many groups held the same protein data and enough chips. A small number of design moves changed the result. Remove one move and accuracy drops. Put them all together and the error falls to a third of the previous best.

One test settles the trade. AlphaFold 2 trained on one percent of the data beats AlphaFold 1 trained on all of it. One unit of insight is worth a hundred units of data.

Then they gave it away. They open-sourced the code and posted predictions for almost every known protein, about two hundred million of them. Biologists typed in their own proteins and saw shapes that matched lab results nobody had published. Trust spread by word of mouth, and work that took months started with a download.

For founders he framed good AI as an amplifier. It turns scattered facts into precise guesses, so the experimenter tests the right thing first. Pick a goal that will thrill real users. Run many cheap tests and skip the elegance. Share tools when sharing helps, because other people push them further than you can.

Fei-Fei Li

Fei-Fei Li returned to one phrase: spatial intelligence. Words are one-dimensional strings. The world is three-dimensional and moves through time, and useful robots need models that hold 3-D space the way we do.

Her own history is the argument. In 2007 she and her students pulled a billion images off the web to build ImageNet. Vision algorithms had no large pile of pictures to learn from. In 2012 a team ran ImageNet on two cheap gaming cards with an old neural-net idea and cut error rates in half. Data plus compute plus the right model moved a whole field at once.

Elon Musk

Musk ran on first principles. Work on things that help many people, and forget the glory. Reduce a problem to core facts and reason up from there. A rocket is metal, fuel, and math. When the raw parts cost a few percent of the final price, the bottleneck is how people build the thing.

He put data centers through the same test. Suppliers told him a giant AI cluster takes two years. He asked which steps consume the time: a building, power, cooling, cables. He rented an empty factory, stacked generators, set chillers, and slept on the floor while crews pulled wire day and night. Break the impossible into parts and the schedule sometimes bends.

If someone pays you, they also pay you with advice. Keep the money and handle the advice with care.

His warning was about ego. The ratio of ego to ability is a silent killer, because feedback stops the moment ego grows faster than skill. Startups die there.

Aravind Srinivas

Srinivas lives inside a scaling storm. Perplexity's servers groan every day as more users arrive, and the team rebuilds everything to carry ten times the traffic. His moat is speed: build, launch, fix, launch again.

Large firms copy anything that makes money. Assume OpenAI, Anthropic, and Google all ship a browser. Your edge is to move faster and care more about small details, and he still stops meetings to fix bugs himself.

At that camp, Perplexity's next swing was Comet, a browser shaped like an agent. One surface holds search, chat, and tasks, with tabs as context and background jobs as execution. An agent that walks the web like a person does not need every site to expose a clean API.

On trust he sounded like a search company. Be correct, be quick, and show your work. For weather or game scores, aim at zero mistakes. For questions with many sides, show several views and let the reader decide, and he treats political bias the same way.

He described a ladder of revenue. Subscriptions come first, pay per task comes next, then a cut of what users buy. You do not need Google margins to win.

He expects AI summaries to send more traffic to large trusted sites and less to thin SEO pages. The long tail thins out, and real brands and real data survive.

Michael Truell

Truell wants to end manual code entry as the main act. The jump comes when people trust a model to change a large codebase without reading every line. Today the professionals read everything, because context windows stay too small, continual learning is weak, and agents lose the thread on long jobs.

Their own shape is worth copying. Their first idea failed, a copilot for mechanical engineers in 3-D CAD. It taught them how to train large models and run them cheaply. They built their own editor rather than an extension, because the change they wanted needed control of the interface at the root.

A public beta shipped three months after the first line of code. They tuned it in public for about a year before growth arrived. Their north star through that year was paid power users, people who open Cursor four or five days a week and pay.

Dylan Field

Field made the case that judgment survives the tooling. As software gets easier to make, design decides more. AI lowers the floor so new people can join and raises the ceiling so experts try wilder ideas. Prompt to app looks finished until you look closely. He expects the roles to blend, and some people who call themselves developers will start calling themselves designers.

On schedules he was blunt. Notice what eats your time, then hire for it or automate it. When a roadmap says nine months, ask what makes it three. Two-year stealth projects are the rare exception. Product-market fit still takes years, and Figma needed five.

Three months to a public beta, a year of tuning in the open, five years to fit. Those durations are the shape of the work rather than a run of bad luck. Day two hundred is where everyone else's interest runs out and yours carries the thing alone. Both of those timelines run well past it.

Jared Kaplan

Kaplan brought the math under the hype. Scaling laws are a map. Grow data, model size, and compute together and error falls along one smooth curve. OpenAI, Anthropic, and Google keep aiming at that curve and it keeps paying them. The same rule now appears to hold in reinforcement learning. If it ever breaks, the cause will be a bottleneck we created.

He told everyone to watch task length. The number of steps an AI finishes alone doubles about every seven months, and the pace is rising. As models get more general they hand people back larger blocks of time. You can give the system longer chains of messy work and trust it to finish.

He listed the gaps without drama. The near ones are deeper real-world knowledge, memory that sticks, and stronger self-correction. Then comes one brain for text, sound, pictures, and video. Then clean scaling to giant jobs and training data that stays aligned with what we ask. Human data still runs the whole thing. It counts most where it teaches a model to handle long-lived tasks and remember past actions.

His founder advice carried the same math. Put AI inside the real task, so the user sees only that the job is done. A feature bolted to the side of a product leaves the job exactly where it was.

Ship before everything works, and attach a readout to what you ship. Ng's weekly eval is the readout. Change one variable between evals, because two changes at once produce a number nobody can read.

The week in one procedure

One procedure survived the whole week. It costs a week to run and nothing to start.

• Pick a real workflow that someone runs today.
• Map the best human version of it, step by step.
• Code the steps that repeat.
• Give the agent the steps that need judgment.
• Keep a human as the final signer.

Then ship it and test it. Trust comes from checks a person can read fast and an interface a person can see through. Give it a week, then grow it or kill it.

Waiting for the next model costs you the week. Pick one workflow and start now.