Jacquard: A Programming Language Designed for AI to Write and Humans to Review

A Programming Language Redesigned for the AI Era

As large language models continue to advance in code generation, a new question is emerging: when code is increasingly written by AI and reviewed by humans, are existing programming languages still the best choice? Recently on Hacker News, an experimental programming language called Jacquard sparked lively discussion. Its positioning is remarkably clear — designed specifically for the collaborative model of "AI writes, human reviews."

The name itself is clever. A Jacquard loom was one of the earliest mechanically programmable devices of the Industrial Revolution, using punched cards for control, and is considered one of the conceptual ancestors of modern computer programming. The machine invented by Joseph-Marie Jacquard in 1804 controlled weaving patterns through punched cards, profoundly inspiring Charles Babbage's Difference Engine design, and extending through IBM's early punched card systems to modern computers. The essence of this lineage is humanity's continuous invention of new "symbol systems" to control machines. Naming a language for the AI programming era after this device carries the implicit message: whenever the structural relationship between humans and machines changes, the language of control itself must be reinvented.

Core Philosophy: Readability Over Writability

Traditional programming languages typically seek a balance between "ease of writing" and "clarity of reading" — often favoring the former. Since code was historically written primarily by humans, reducing keystrokes and improving development efficiency were important goals. But in the new landscape where AI dominates code generation, this tradeoff is shifting fundamentally.

It's worth noting that "reviewability first" is not an entirely new concept in programming language history. Ada (designed for the U.S. Department of Defense in the 1980s) placed "explicit, unambiguous, verifiable" at its core, sacrificing conciseness for reliability. MISRA C restricts dangerous C features to ensure code reviewability in safety-critical domains like aerospace. Jacquard's innovation lies not in applying constraints to existing languages, but in building the reviewer's experience as the primary design principle from scratch — and doing so against the entirely new assumption that AI is the primary code producer.

Why Reviewing Matters More Than Writing

Jacquard's design premise is: when AI can produce large volumes of code at near-zero cost, the real bottleneck is no longer "how fast can we write" — it's whether humans can efficiently and accurately understand and verify AI-generated code. Language design should therefore pursue:

• Lower comprehension cost: Code semantics should be as explicit and unambiguous as possible, minimizing "implicit behavior" and "magic syntax" so reviewers can immediately grasp program intent.
• Reduced cognitive load: Avoid the "fun to write, painful to read" shortcuts in favor of clear structure and transparent logic.
• Better diff readability: In workflows where AI iteratively regenerates code, humans frequently review diffs — language structure should make it easy to quickly locate changes.

The root of the cognitive load problem deserves special attention: syntactic sugar. Syntactic sugar refers to language features that make code "sweeter to write" without adding expressive power — Python's list comprehensions, JavaScript's optional chaining operator, Rust's pattern matching shorthands. These features reduce input cost for experienced authors but often impose implicit comprehension barriers on readers, who must already be familiar with the sugar's semantics to quickly decode intent. When AI can use all syntactic sugar without friction, the cognitive decoding burden on human reviewers is significantly amplified. Jacquard's direction resembles a "desugaring" design: trading more explicit code for lower reading friction.

In other words, Jacquard attempts to elevate "reviewability" to a first-class citizen of language design — a sharp contrast to the design philosophy of mainstream languages over the past several decades.

A Paradigm Shift in AI Programming Workflows

The emergence of this language reflects deep changes underway in software development. From GitHub Copilot to Cursor to various agent-based coding tools, AI-assisted programming has evolved from "code completion" to "autonomously writing entire sections or even entire modules." The developer's role is shifting from "author" to "reviewer and director."

The "Mismatch" Problem With Existing Languages

AI still writes code in languages like Python, JavaScript, and Rust — languages designed for humans — which creates several subtle mismatches:

• These languages contain abundant syntactic sugar designed for human writing convenience. AI naturally employs it, which ironically increases the difficulty of human review.
• Type systems, error handling, and other mechanisms are designed around "preventing human mistakes," not necessarily "verifying AI output."
• The diversity of coding styles means a single feature can be implemented multiple ways, increasing uncertainty during review.

Jacquard's approach: since the writing work can be delegated to AI, we should design a language that AI can easily generate correctly, while humans can easily verify for correctness — realigning the human-AI collaborative workflow from the ground up.

Community Reaction and Practical Considerations

Based on the Hacker News discussion, Jacquard remains in early experimental stages and has not yet attracted large-scale attention. But the questions it raises deserve serious consideration across the industry.

Supporters argue that designing a programming language specifically for the AI era is a reasonable evolutionary direction. When tools and contexts change, the most fundamental abstraction layer — language itself — should evolve accordingly.

Skeptics point out that AI models are trained on massive amounts of existing code (Python, JS, etc.), and a brand new niche language lacks training data, meaning AI might actually generate it worse. This concern points to the deep mechanics of how LLMs generate code — model performance on code generation is highly dependent on the scale and quality of pretraining data. Python, JavaScript, Java, and other languages have billions of lines of high-quality open-source code on GitHub, which is fundamentally why Copilot, Claude, GPT-4, and similar models perform so well in those languages. A brand new language faces a "cold start dilemma": lack of training data leads to poor model generation quality, poor quality discourages developer adoption, and without adoption, training data never accumulates. Possible paths out of this trap include: providing formal grammar specifications for model reasoning, designing for conceptual alignment with existing languages, or fine-tuning with synthetic data — but all of these require substantial ecosystem investment. Furthermore, ecosystem, toolchain, and community — these are thresholds that are very hard for new languages to clear.

A Deeper Implication

Setting aside whether Jacquard itself can succeed, it touches on a critical question: when AI becomes the primary producer of code, should our entire software toolchain — including programming languages, IDEs, version control, and testing frameworks — be reexamined for their underlying design assumptions?

This question is more profound than it appears on the surface. The vast majority of design decisions in the modern software toolchain implicitly assume "humans are the primary authors": Git's diff algorithm optimizes line-level changes for human reading habits; IDE autocomplete assumes the author already has intent in mind and just needs to reduce keystrokes; unit testing frameworks default to tests being written by people who understand the business. When AI becomes the primary code producer, these assumptions begin to loosen. A new toolstack might need: version control oriented around semantics rather than text lines, test generators that automatically verify whether AI output intent matches human specifications, and code provenance systems that track the history of "AI-generated vs. human-review-approved."

In the past, these tools defaulted to "humans as primary authors." In the new paradigm of human-AI collaboration, what we may need is an entirely new toolstack that is "AI-friendly and human-reviewable." Jacquard is an early exploration in this direction — and the trend it represents may become increasingly clear over the coming years.

Conclusion

Jacquard is a quintessentially "small but sharp" experimental project: it may never become mainstream, but it precisely identifies a widely overlooked problem in the AI programming era — in a world where code is written by machines and reviewed by humans, who should the language itself be optimized for?

For developers interested in the future of AI programming, the value of projects like this lies not in immediate usability, but in their ability to raise the right questions early. As AI-generated code gradually becomes the norm, the design philosophy of "reviewability first" may ultimately move from the margins to the center.

Key Takeaways