Opportunities Surfaced by AI Lags
The Federal Reserve knows something important about timing: policy works with lags.
Economists identify three distinct lags in monetary policy:
- Recognition lag: the time it takes to identify that a problem exists
- Implementation lag: the time it takes to enact a response
- Impact lag: the time it takes for the response to affect the economy
The Fed might recognize inflation in Q1, implement rate hikes in Q2, and see effects in Q4. Each lag compounds. Get any of them wrong, and policy arrives too late or overshoots.
These same lags appear in technology.
Recognition, Implementation, Impact: The Three Tech Lags
Recognition lag: How long until people realize a technology matters? Bitcoin launched in 2009. Most institutions didn’t recognize its significance until 2017 or later. GPT-3 launched in 2020; the recognition lag was shorter, but still measurable.
Implementation lag: How long to build useful applications? Ethereum launched in 2015. Meaningful DeFi applications didn’t emerge until 2019-2020. Four years of implementation lag.
Impact lag: How long until the technology changes behavior at scale? Smartphones had a decade-long impact lag before they transformed commerce, communication, and media consumption.
AI Lags Are Compressing Faster Than Previous Tech
Different technologies have different lag profiles:
| Technology | Recognition | Implementation | Impact |
|---|---|---|---|
| Internet | ~5 years | ~10 years | ~15 years |
| Smartphones | ~3 years | ~5 years | ~10 years |
| Blockchain | ~8 years | ~5 years | ongoing |
| LLMs | ~2 years | ~2 years | ongoing |
AI is moving faster. The lags are compressing. But they still exist.
Push the Frontier or Close the Adoption Gap
Understanding lags reveals two distinct opportunities.
Path one: Push the state of the art forward. Reduce the implementation lag by building better tools, infrastructure, and primitives. This is research and development work.
Path two: Focus on adoption. Work within the impact lag by bringing existing technology to people who don’t yet use it. This is distribution and product work.
Both paths create value. The first makes things possible. The second makes them real.
Most attention goes to path one. Breakthroughs make headlines. Research papers get cited. Frontier labs raise billions.
Path two gets less attention but matters as much. Someone has to bring technology from the lab to the world. The implementation lag closes, but the impact lag remains. Billions of people still don’t use technologies that have been viable for years.
Lags Create Arbitrage for the Well-Positioned
Lags create arbitrage. If you understand where a technology sits in its lag cycle, you can position accordingly.
During the recognition lag: learn deeply, build conviction, accumulate expertise.
During the implementation lag: build infrastructure, tools, and primitives that others will need.
During the impact lag: focus on distribution, user experience, and adoption.
Many builders chase the frontier. Fewer work on closing the gap between what’s possible and what’s actual. Both matter. The lags determine which matters when.
Indicators: Institutions, Boring Building, Parents Using It
The Fed’s challenge is that lags are variable and hard to predict. Technology faces the same problem. You can understand the lag framework without knowing exactly where you are in it.
What helps: watching leading indicators. Recognition lag closes when serious institutions engage. Implementation lag closes when building becomes boring. Impact lag closes when your parents use it.
None of this guarantees timing. But it provides a framework for thinking about it. And in technology, as in monetary policy, timing often matters more than being right.
Code Assistants Widen Developer Productivity Gaps
The lag framework becomes more interesting when you look at what’s happening now.
Platforms subsidizing product development: Every major ecosystem now offers free tiers, credits, and tooling that let builders prototype without capital. This compresses the implementation lag dramatically. What used to require funding can now be built on weekends.
The knowledge-application gap widens: Information has never been more accessible. Tutorials, documentation, example code. All free. But the gap between knowing something exists and successfully applying it keeps growing. The value isn’t in knowing; it’s in doing.
Developer productivity divergence: Some developers have figured out how to use code assistants effectively. Others haven’t. The productivity gap between these groups is widening. Two developers with the same title can have 5x different output now.
Language expertise moats have collapsed: Companies still require “5+ years of Rust experience” but AI makes language acquisition fast. The hiring market hasn’t adjusted. There’s a recognition lag between what experience signals and what it actually predicts.
Code assistants enable deeper stacks: Previously, you’d pick a stack you knew and stay there. Now you can credibly work across languages, frameworks, and domains that would have taken years to learn. Features that were unrealistic for small teams become feasible.
More refactoring, not less: Counter to expectations, code assistants lead to larger changesets. When refactoring is cheap, you do more of it. Codebases get restructured more aggressively. The economics of technical debt have shifted.
Freemium’s inevitable end: Startups subsidize usage to grow, then raise prices once they’ve captured the market. We’re watching this cycle accelerate. The free tools builders rely on today will cost money tomorrow. Build accordingly.
The junior developer paradox: It’s never been easier to learn to code. Documentation is better, AI can answer questions, onboarding is smoother. Simultaneously, companies are hiring fewer juniors. The skills needed for entry have risen while the patience for training has fallen.
Configuration as competitive advantage: We’re still in the early days of figuring out optimal code assistant workflows. Prompting strategies, context management, tool selection. This knowledge isn’t widely distributed yet. Developers who master this now have an advantage during the lag.
Geographic perception gaps: The west coast tends to underestimate how long adoption takes in the rest of the country. The east coast tends to overestimate the lag. Reality is somewhere between San Francisco’s “everyone uses this already” and New York’s “this isn’t ready for serious business.”
Opportunity cost of opportunities: During transition periods, opportunities multiply. But each opportunity you pursue is time not spent attacking the lag directly. Building things that work today can distract from building things that will matter tomorrow. The right balance is hard to find.
The lags aren’t just a framework for understanding timing. They’re a framework for understanding where to focus. And right now, there’s significant value in understanding how code assistants change the game, before that knowledge becomes table stakes.