The Language That Writes Itself

Why Programming Languages Should Evolve Like Living Systems

A meditation on pattern recognition, linguistic evolution, and what happens when we let our tools learn from us

I was watching a conversation between Anthropic and a few of the team at Cursor the other day when something clicked. They were discussing how AI coding assistants would eventually handle larger and larger "chunks" of functionality… entire features, complex refactors, architectural decisions. But as I listened, I realised they were describing something more profound than just better code generation.

They were describing the birth of new languages.

The Pattern We Can't Unsee

Think about how you code. Not the syntax you use, but the patterns you repeat. Every codebase develops its own dialect, idioms that appear hundreds of times, semantic patterns that encode your team's hard-won knowledge about how things should work.

In an e-commerce system, you might write this pattern endlessly:

user = get_user(user_id)
if not user or not user.is_active:
    return error_response()
if not user.has_permission('purchase'):
    return forbidden_response()
cart = get_cart(user.id)
# ... actual business logic

We've accepted this repetition as the cost of clarity. But what if it didn't have to be?

The Meta-Language Vision

Here's the radical idea: What if programming languages could observe these patterns and evolve to absorb them? Not as libraries or frameworks, but as first-class language constructs that emerge from actual usage.

Imagine if, after sufficient repetition, your language evolved to let you write:

with validated_purchasing_user(user_id) as user, cart:
    # ... actual business logic

But here's the key: you didn't write validated_purchasing_user. Nobody did. It emerged from your codebase's patterns and became part of the language itself, as fundamental as if or while.

Why This Matters More Than You Think

This isn't just about saving keystrokes. It's about acknowledging something we've been dancing around since we started building AI coding tools: code itself wants to evolve.

Every time Cursor or Copilot correctly predicts an entire function, it's showing us that our code has reached a level of pattern density where higher-order abstractions are begging to exist. The AI sees it. We feel it. But our languages remain frozen in time.

The Living Language

What I'm proposing is a language that lives and breathes with your codebase:

• Pattern Recognition: Continuously analyses semantic patterns (not just syntax)

• Threshold Evolution: When patterns cross usage thresholds, they become language primitives

• Codebase Dialects: Each project evolves its own extensions while maintaining a stable core

• Semantic Understanding: The compiler/interpreter deeply understands these patterns, enabling optimisations impossible with regular functions

This means your financial trading system might evolve primitives like atomic_order_execution while a healthcare system develops hipaa_compliant_data_access. Both would be first-class constructs in their respective contexts.

The Philosophical Shift

This represents a fundamental inversion of how we think about programming languages. Instead of languages being designed by committee and frozen in specification, they would grow from the ground up, shaped by actual use.

It's biomimetic programming, i.e., languages that evolve like living systems, adapting to their environment (your codebase) and developing specialised organs (domain-specific primitives) for survival.

What This Enables

If we get this right, we're not just making programming easier. We're creating a world where:

1. Institutional knowledge becomes executable - Your team's best practices literally become part of the language

2. Onboarding accelerates - New developers learn your domain through the evolved language constructs

3. AI assistance deepens - Instead of generating boilerplate, AI can work with higher-order primitives that encode real business logic

4. Quality compounds recursively - Each abstraction layer enables the next, accelerating improvement

The Cursor Connection

Watching Cursor's evolution, it's clear we're approaching a inflection point. The AI can see the patterns. It can generate them. The next logical step is letting those patterns reshape the medium itself.

This is why I think Anthropic should acquire Cursor, but not for the reasons you might expect. It's not about owning a coding tool. It's about recognising that code generation might be the primary interface through which AI reshapes the world. And if that's true, then evolving languages (languages that learn) become the substrate on which that reshaping happens.

The Question That Matters

Here's what keeps me up at night: Are we brave enough to let our tools evolve beyond our specifications? Can we embrace languages that know things we don't, that encode patterns we haven't consciously recognized?

Because if Cursor and similar tools have taught us anything, it's that there's a vast space of useful abstractions waiting to be discovered. The question isn't whether our languages should evolve to capture them.

The question is whether we'll let them.

---

What patterns in your codebase would you want to see become language primitives? What would your code's evolved dialect look like? I'd love to hear your thoughts.