The Missing Link
How Evolving Languages Enable AI to Heal the World
When programming languages evolve to match AI capabilities, the boundary between intention and implementation dissolves
I've been postulating around two technological convergences that initially appeared separate but revealed themselves as interconnected forces reshaping computing's future.
First: programming languages that evolve based on usage patterns, automatically promoting common code into new primitives.
Second: AI sophisticated enough at generating code that it becomes humanity's primary problem-solving mechanism.
The deeper I explored each concept, the clearer their symbiotic relationship becomes. One enables the other.
The Expressiveness Ceiling
Recent research illuminates a fundamental constraint on AI code generation. GitClear's 2025 report documents a 4x increase in code duplication across AI-generated code, while Stack Overflow's 2024 survey revealed that 31% of developers remain skeptical about AI accuracy.
The underlying issue transcends AI capability. When AI writes Python or JavaScript, it operates within the expressive boundaries those languages provide. Cleverness within constraints has limits.
Current programming languages were designed for humans giving computers step-by-step instructions. When AI needs to express solutions at the scale of cities, ecosystems, or global supply chains, the mismatch becomes stark. Civilisation-scale problems require civilisation-scale primitives.
Consider the difference between being eloquent in a language versus inventing new words when existing ones fail you.
Evolution as Bridge
Since publishing my first exploration of this topic, technical feedback has refined my understanding. Whether these abstractions live in compilers or sophisticated libraries matters less than their fundamental capability: patterns automatically promoting themselves into reusable, composable abstractions.
Healthcare systems where patterns evolve into domain primitives demonstrate this power. Not just validate_user, but ensure_hipaa_compliant_access and coordinate_specialist_referral. These capture code patterns and encoded domain expertise.
The compounding effect creates the real transformation:
Basic patterns become primitives.
Primitives combine into domain operations.
Domain operations enable system orchestration.
System orchestration enables societal transformation.
Each layer makes the next possible. Each layer evolves based on what actually works in practice.
The Feedback Loop Revolution
As AI uses evolved abstractions to build solutions, it generates new patterns. Successful ones get absorbed back into the language ecosystem. This creates an accelerating cycle where both AI and language capabilities grow together.
Traditional software development resembles building with fixed-size bricks. This approach creates bricks that merge and reshape based on construction needs, eventually providing exactly the building blocks required.
Urban Planning as Concrete Example
Today, addressing urban housing shortages through AI requires generating massive amounts of low-level code - database operations, API calls, form validations. Millions of lines dancing around the actual problem.
(Note: I'm being provocative with this example because I've chosen an area that I suspect has particular resonance with at least one of the people who's opinion I value tremendously... and they may well shoot this entire thing down)
Consider if the language had already evolved urban planning primitives from thousands of successful projects:
available_sites = identify_buildable_parcels(city)
optimal_projects = generate_mixed_income_proposals(sites)
for project in optimal_projects:
permits = navigate_zoning_variance(project)
financing = structure_public_private_partnership(project)
community = build_stakeholder_consensus(project)
if constraints_satisfied(permits, financing, community):
execute_development_pipeline(project)These represent patterns that emerged from successful urban development projects and achieved first-class abstraction status. AI operates at the level of urban planning rather than database updates.
Market Forces Converging
Current market positioning creates an interesting dynamic. Anthropic has built AI explicitly optimised for building things, creating systems so capable that CEO Dario Amodei predicts AI will write 90% of all code within 3-6 months. They've proven AI can serve as genuine thought partner for complex technical work.
Cursor observes millions of developers writing code daily, collecting unparalleled data about which patterns emerge, which abstractions developers reach for, where current languages fall short. They understand what developers actually need languages to do.
The Model Context Protocol that Anthropic launched demonstrates how quickly new standards spread when they solve real problems. Applied to evolved programming abstractions, that adoption curve could transform development fundamentally.
Evolution Timeline
The progression won't follow clean phases, and timelines are speculative, but the evolution is underway:
Pattern Recognition (Today)
AI identifies common patterns across codebases. Developers manually extract the best ones into libraries. Early experiments with automatic abstraction generation begin.
Accelerated Evolution (2-5 years)
AI suggests new abstractions based on usage patterns. Domain-specific libraries proliferate rapidly. The line between "library" and "language feature" blurs.
Compound Capabilities (5-10 years)
Abstractions build on abstractions at increasing speed. AI works primarily at high levels of abstraction. Solutions to complex problems become expressible in manageable code.
Reality Orchestration (10+ years)
Evolved abstractions reach sufficient sophistication. AI can express and implement society-scale solutions. The gap between intention and implementation effectively disappears.
The Subtle Recognition Advantage
Technical commenters have (inadvertently or otherwise) given me confidence in a crucial insight: the real power lies beyond obvious patterns. Any decent developer can extract those into functions. The advantage comes from recognising subtle, almost-but-not-quite-identical patterns across millions of codebases.
These are patterns humans miss. Code that's 90% similar but differs in ways that make extraction messy. AI can hold all variations in memory simultaneously, spot core abstractions, and generate solutions that handle all cases elegantly.
This amplifies human intention through better tools for expression rather than replacing human creativity.
Removing the Ceiling
The complexity of problems AI can solve is directly bounded by the expressiveness of the languages it uses. Today's languages create an artificial ceiling on AI capability -not because AI can't generate complex code, but because it must express grand solutions in primitive operations.
Evolved languages remove that ceiling. They enable AI to work at the level of intention rather than implementation.
When AI can express "ensure sustainable urban development" as easily as "increment counter," we've fundamentally changed what's possible. The infrastructure for AI to become a genuine force for solving humanity's challenges emerges from this transformation.
The Inevitable Trajectory
AI code generation improves exponentially while approaching the expressiveness wall. We can accept that limitation - keeping AI as an impressive but bounded programming assistant - or evolve our languages to match AI's growing capabilities.
The trajectory makes this evolution inevitable. The question becomes whether we'll guide this transformation or stumble into it unprepared. And whether we will harness its true potential in a timely enough manner to address the larger societal and humanitarian issues.
The languages that will reshape our world don't exist yet. The patterns that will become their primitives are being written right now, in every codebase, in every solution, in every repeated abstraction that begs to become something more.
---
What patterns in your daily work feel like they should be language primitives? Where do you see the first domain-specific evolutions happening? The future of programming might be less about writing code and more about recognising which patterns deserve to evolve.