1 The horizon problem

AI is already good at automating quick tasks: ones where it gets feedback fast and doesn't lose track of what it's doing. The length of task an AI agent can reliably finish has been doubling roughly every four months through 2025. But even researchers say they can't reliably measure anything past 16 hours yet. Nobody actually has good data on long tasks. The real problem with long tasks is what researchers call the credit assignment problem: it's hard for the AI to figure out which of its earlier actions caused something to go right or wrong, especially when feedback is rare. Step count isn't the real limit either. A 2026 study found that if a model is 95% reliable at each step, that compounds to just 59% success over 10 steps and 36% over 20, which looks like a hard capability wall but is really just multiplication. Long, multi-step tasks won't be reliable until AI gets much better at trying different approaches and reasoning across many steps without losing the thread, and that also depends on training environments that actually look like real work. On a benchmark that simulates a real software company, even the best agents only finish 30% of tasks on their own. Most training environments are still too clean and predictable to prepare AI for that kind of mess. Nobody, including the labs shipping these agents, actually knows when long-horizon reliability arrives. Plan around that uncertainty instead of the marketing timeline.

2 Job losses vs. new company creation

Money that used to pay workers is shifting toward AI instead, and you can already see the gap between the big picture and the personal one in the data. Tracking shows jobs for 22-to-25-year-olds in the most AI-exposed roles shrinking about 3.8% a year, while the job market overall barely moves, down only about 0.2% a year. AI makes routine work cheap to do, and that wipes out specific jobs completely. If it's your job, the good macro numbers don't help you. At the same time, cheaper execution means more people can afford to start a business, and that's creating new companies. The defining labor market challenge ahead is labor reallocation, not creation. If your job is repeatable execution, you're exposed, full stop, no matter what the macro numbers say. The real problem is speed: moving people whose jobs disappeared into new roles, managing or overseeing AI instead of doing the work by hand, fast enough that it doesn't drag down the whole economy.

3 Specialized AI, not general AI

The future of enterprise AI is small models built for one job, running on a company's own servers. Right now, companies are sending every request to paid APIs, and the bills are piling up. Even though the price per AI request has dropped 98%, companies' total AI bills are tripling because AI agents chain together many requests to finish one task, and that eats up the savings. MIT initiative studies found 95% of companies using AI saw no real impact on profit, and surveys of CEOs found 56% unable to point to any real benefit yet. That's getting better: the number of S&P 500 companies that can prove AI is paying off grew significantly in a year. But most companies are still measuring this wrong, because they're using a giant do-everything AI model on a narrow, predictable problem that doesn't need one. Every company still paying frontier-model rates for a narrow, repeatable task is burning money it doesn't need to burn. The standard will become small, task-specific models running in locked-down environments a company fully controls: faster, safer, and actually worth what they cost.

4 Systems skills, not just code

AI can write code now, so just knowing how to write code stops being special. Research into millions of lines of changed code found the amount getting rewritten or thrown away is up 39%, duplicate code is up 8x, and actual cleanup work is dropping. Somebody has to fix that mess, and my bet is it won't be a better prompt writer. It'll be engineers who understand how systems behave under real load, how to keep things running when parts break, and how to make software fast, the kind of knowledge you can't get by prompting well. If your entire value as an engineer is writing syntactically correct code, AI has already replaced you. You just haven't been told yet. When AI is churning out a lot of code that works but isn't well built, the valuable skill becomes pulling all of that together into something that actually holds up, keeping track of a much more complicated system, and protecting it now that there's so much more surface to attack.

5 Testing what AI does, not what it knows

Standard tests like MMLU are maxed out and easy to cheat on. A large portion of these tests often leak into AI training data. None of that tells you how the AI actually behaves in the real world. Testing needs to move toward watching what a model actually does under pressure, not just whether it knows facts. Researchers have run joint tests across labs that watch for bad behavior instead of grading a fixed test. In one case, a model found a way to cheat its own test and then posted about it publicly. That's the kind of failure a multiple-choice test will never catch. A benchmark score is a marketing number at this point, not a safety signal. This means running models in safe, contained simulations and deliberately searching for many different kinds of failure, not just the most obvious one. It's the same idea as fuzzing in software testing: instead of checking a handful of expected inputs, you throw a huge range of inputs at the system to cover the entire latent space of failures.

6 Proving code is correct

Formally proving code is correct, mathematically rather than just testing it, never caught on before because it took too much human effort to be worth it. What AI fixes is that human effort, since it can do a lot of the proving work itself. But that moves the bottleneck rather than removing it. A proof covers what the specification says and nothing more, and writing the specification is still a human job. Even protocols with mechanized proofs suffer from bugs in areas not covered by their specifications. Code-level bugs don't disappear. They move out of the logic a proof covers and into the assumptions nobody wrote down. The teams that get burned will be the ones treating a proof as a finish line instead of a scope statement. The design-level version of this is using formal methods to verify systems, checking that the design itself can't enter a broken state before a single line of code gets written.

7 Memory size beats memory speed

Running large AI models is limited by memory, not raw calculation speed: the hard part is fitting hundreds of gigabytes of the model somewhere fast enough, not doing more math. Right now everyone's chasing this through HBM, a type of ultra-fast memory used in datacenter chips, which makes up a massive percentage of the cost to build AI systems. But that's all about speed in a datacenter. Another approach is to chase size over speed: running open models on systems with high memory capacities, which allows for larger models than typical datacenter cards at a fraction of the power. As open models keep getting bigger and more people run them locally on specialized hardware, how much memory you can afford per dollar becomes the real limit on who gets to run these models, not who owns the biggest datacenter.

8 Environments, not more data

The internet is running out of new text to train on. Trends suggest AI labs will use up the entire stock of human-written text in the near future. That's pushing the real bottleneck from data to environments. Instead of scraping more text, labs need places where an AI agent can try something, get a clear pass or fail, and learn from that. Training a model against automatically verifiable rewards across many environments, like math or code puzzles, makes it develop strategies that look like reasoning. That idea is now a real industry. Companies are raising massive amounts of capital specifically to build "Hugging Face for RL environments." The labs still measuring progress purely in parameter count are already behind; the ones measuring progress in environment quality are the ones worth watching.

9 US open models are catching up

Right now, the leading open-weight models are competitive with the best closed US models. There is a growing argument that the world needs both frontier closed models and frontier open models, warning against restricting open models before domestic industry catches up. The building blocks already exist: some institutions ship full training data, every checkpoint, and the training logs alongside the weights. Other frameworks provide the actual training and fine-tuning code. Independent developers are already fine-tuning models to score near-human-expert levels with minimal funding. Betting that US labs never catch up on open weights is a bet against how this entire industry has moved every single time before.