Agent-Oriented Programming Languages
The emerging idea that programming languages will diverge into human-readable forms and more structured, heavily-typed or agent-specific forms optimized for AI agents to read and write.
Also known as: agent-specific languages, heavily typed languages, languages that support a more structured approach, just for agents
Part of: Agent-Native Design
Documents (2)
- Does code quality still matter? Mark Seemann · 2026-07-23 source ↗ Reader 🖥️
Because code quality as currently understood is entirely reducible to the constraints of human cognition, Seemann argues that a hypothetical future in which LLMs alone write, read, and maintain code — in machine-optimized languages rather than human ones — could render today's code-quality concepts meaningless, yet some structurally analogous form of technical debt would likely still emerge from LLMs' own constraints, and only the LLMs' own accumulated experience (not humanity's software-engineering literature, which is inescapably about human cognition) could diagnose and correct it. - The "funhouse mirror": How AI reflects the hidden truths of your software pipeline Rachel Laycock (interviewed by The New Stack) · 2026-07-07 source ↗ Reader 🖥️
AI is not a disruptor but an amplifier of your existing pipeline, so because writing code was never the bottleneck, its coding speed turns a velocity multiplier into a debt accelerator wherever software-delivery fundamentals, guardrails, and stewardship of newcomers are not already in place.
Tensions
How should newly-empowered citizen developers be made safe — constrained platform, human stewardship, or supported API-first tooling?
from: What is the future of software development in the agentic/AI age?
- Looking back at the Future of Software Engineering unconference (Bartosz Ocytko): A tightly-constrained, self-healing platform — not universal upskilling — should absorb citizen developers.
- The "funhouse mirror": How AI reflects the hidden truths of your software pipeline (Rachel Laycock (interviewed by The New Stack)): Senior technologists must act as stewards — teaching the 'why' and building guardrails, not gatekeeping or replacing juniors.
- AI Is Changing Software Engineering. The Fundamentals Still Matter. (Abby Bangser): Support, don't restrict — provide API-first, MCP-accessible tooling that non-engineers can safely consume.
Assessment: All three agree citizen developers are inevitable and must not be blocked, but the safety mechanism differs — encode it in a constraining platform (Ocytko), transfer it through human relationships (Laycock), or expose it as consumable interfaces (Bangser). Ocytko's platform-first case is strongest on the specific failure mode both he and Ördög name (non-engineers leaking or bypassing production-data access), which stewardship alone cannot prevent at scale. Laycock's stewardship answers a different problem — sustaining the junior-to-senior pipeline — that a platform does not. The positions are complementary in principle but compete for the same finite investment, and none supplies a concrete governance model for vibe-coded shadow IT.
Open gaps (3)
- incompleteThe essay never specifies what would motivate humans to actually remove themselves from the code-review/responsibility loop, given that Seemann's own opening premise is that quality matters precisely because humans remain accountable for the code. The thought experiment assumes away the accountability structure (legal, commercial, safety) that currently keeps humans in the loop, without discussing why or how organizations, regulators, or liability regimes would ever permit that removal.Does code quality still matter? — read next: Look for material on AI accountability and liability for autonomously-generated/deployed software (e.g. discussions of 'who is responsible when an agent's code causes harm') to see whether any serious proposal actually argues for full removal of human accountability, as opposed to full removal of human code-reading.
- incompleteThe essay treats 'LLaMe' as if a single dominant LLM-native language would emerge, but does not address the more likely alternative that many competing model providers, toolchains, and legacy-interop requirements would produce multiple incompatible machine-oriented representations (or none at all, if models keep generating human-readable languages for interoperability with existing systems, tooling, and each other).Does code quality still matter? — read next: Cross-reference with material on agent-oriented/agent-native programming language proposals (e.g. discussions of languages diverging into human-readable vs. heavily-typed/agent-specific forms) to see whether any convergence-vs-fragmentation argument is made explicitly elsewhere in the corpus.
- incompleteThe essay does not engage with the possibility that LLMs already effectively 'read' code today (via their own context windows and training) using representations quite unlike human perception, which suggests the thought experiment's stark before/after framing (human cognition vs. some future LLM cognition) elides a more gradual, already-underway shift in what 'reading code' even means for a model versus a human.Does code quality still matter? — read next: Look for empirical or interpretability work on how LLMs internally represent code (e.g. token-level vs. structural/AST-level processing) to assess whether 'LLM cognition of code' is already a distinct, non-human-cognition regime today, rather than only in Seemann's hypothesized future.