"it's football season, make sure we are recommending the FIFA world cup to our users who like other sports content etc."
models/fifa_catalog.json and user affinity rules...GetSeasonRecommendations() in api/recommender.goYou can prompt the model to try again or start a new conversation if the error persists.
See our troubleshooting guide for more help.
§1: The Shift
Developers can write 10x more code. But is this really leading to 10x better outcomes? We need to change how we think about code (and coding).
"Code is no longer the destination. It is becoming an opaque intermediate target—a transient byproduct generated and checked by systems."
Development Today
Code is written by hand (or with the help of Generative AI), but the AI never grasps the full extent of the problem.
Spec-Driven Intent
Micro-decisions recorded in declarative protocols. Code generation and verification are fully automated.
§2: The Illusion of Speed
For decades, the holy grail has always been speed: how do we go from idea to execution faster? We invented higher-level languages, frameworks, agile methodologies, and CI/CD pipelines—all in the pursuit of writing and shipping code faster.
Then, Generative AI arrived, and suddenly we had the ultimate speed machine. You can now prompt an LLM and watch it spit out 1,000 lines of complex boilerplate in seconds.
"It feels like magic. It feels like we finally won."
Speed cuts both ways. When managed with discipline, AI coding dramatically accelerates development; without strict architectural guardrails, however, we risk generating unmaintainable code that silently degrades our foundation over time.
1,000 Lines in Seconds
Prompting an LLM generates massive boilerplate instantly, creating an intoxicating illusion of victory while bypassing architectural comprehension.
Velocity Without Visibility
When code generation outpaces human review, the gap between "what the code says" and "what the system actually does" expands exponentially.
Agentic Coding Births the 10x Programmer
Through autonomous multi-agent synthesis and specification-driven development, a single engineer now commands the throughput of an entire traditional engineering organization.
"Have we ever witnessed this kind of an explosion in programmer productivity in human history before?"
At first glance, this exponential velocity feels totally unprecedented. But is this moment truly unique?
Yes! Grace Hopper & The First Compiler
In the early 1950s, Grace Hopper revolutionized computing by inventing the first compiler (`A-0`), a breakthrough that transformed computers from glorified calculators into accessible, general-purpose tools. This triggered a >1000x productivity leap.
§3: Auto-scaling Our Mistakes
"With AI, we aren't just writing code faster. We are auto-scaling our mistakes. If we are using AI to go fast, but aren't maintaining a high signal-to-noise ratio, we are actually going backwards in productivity."
Backwards Productivity
If we use AI to go fast without maintaining a high signal-to-noise ratio, our velocity is illusory. We are actively moving backwards as unverified logic piles up.
The Crappy Code Ratio
If the rate of crappy code being generated is greater than the rate of productive, verified code, every prompt actively degrades our foundation.
The Weight of Slop
Without strict specification guardrails, our projects will eventually and inevitably collapse under the weight of their own unreadable, unmaintainable slop.
"For each desired change, make the change easy (warning: this may be hard), then make the easy change."
§4: The Blank Slate Test
Ask yourself: Imagine you lost all your code. Are you able to re-bootstrap your project from scratch without existing code?
Are you effectively able to generate the 'how' from the 'why' and the 'what'?
Intent & PRD
Business outcomes, user needs, and core value proposition stored in immutable markdown.
Spec & Guardrails
Declarative schemas, architectural boundaries, API contracts, and invariant rulesets.
Disposable Code
Synthetic logic generated on-demand. If wiped, the engine re-compiles identical behavior instantly.
Sanchit Alekh
AI Customer Engineer // Google
Bringing the best of Google's AI Technologies to build intelligent solutions for customers.
Attribution The original "Design is the New Code" concept and framework was created and pioneered by Dave Rensin, Distinguished Engineer at Google.
§5: THE EAGER
RUNAWAY
It is tempting to dive right into syntax. But AI models are eager to please—which means they will happily sprint off an architectural cliff if you don't anchor them first.
Stop Thinking About The Code
Before writing a single line of code, focus entirely on assembling your upstream context artifacts.
Your design documents, user journeys, architecture diagrams, and even developer debates from Slack are the fuel. This human judgment is the exact ammunition the agent needs to write correct-by-construction code for you.
§6: The Vanishing Code
When code becomes opaque, the only artifact that matters is the design.
Micro-Decisions Critical
Historically, human developers made thousands of subtle architectural judgments right at the keyboard, leaving a rich trail of micro-decisions embedded inside the logic.
A Future without Code
When you ask AI for a picture of a cat, it does not generate a Python script automating MS Paint to draw it—it outputs the pixels directly from intent.
Design is Paramount
Even today, LLMs generate code at a velocity and volume that makes traditional line-by-line human code review mathematically impossible.
We must stop managing the byproduct (syntax) and start governing the source of truth (design).
DESIGN IS
THE NEW CODE
When the "how" is automated, the "what" is the only remaining lever. Structure, intent, and interface become the source of truth.
§8: FEED THE ELEPHANT, TEST AGAINST THE GOLDFISH
THE ELEPHANT MODEL
Long-term structural memory. The architectural bedrock (`spec.md`, `design.md`) that remains immutable through version cycles. It is the "What" that defines the soul of the product.
THE GOLDFISH MODEL
Ephemeral context window. The immediate syntax, local variables, and transient logic that shifts with every prompt. High-velocity, low-retention.
§9: DECOUPLING
INTENT
We move from a single monolith of code to a tiered Specification Stack. Each layer serves a specific cognitive function for the orchestrator.
prd.md
The product requirements document. Defining user needs and business constraints without technical pollution.
design.md
The structural blueprint. Defining component relationships, state machines, and API contracts.
GEMINI.md
The execution bridge. LLM-specific instructions, prompting strategies, and tactical implementation guides.
"When intent is decoupled from implementation, the cost of change approaches the speed of thought."
§10: Elephant and Goldfish
How do you know if your design doc is actually good, or if it's just relying on the hidden context built up in your session? You test it against a Goldfish.
Teaching & Growing the Elephant
THE ABSOLUTE SOURCE OF TRUTHWe create the Markdown document that will serve as the absolute source of truth and guardrails for the code. Do not ask the AI to write the whole doc at once due to output token limits. Build it iteratively in the same chat session:
Have the AI write a plain English description of the business problem.
Have it write a jargon-light description of the big components and how they fit together.
Document the ideas you considered but ruled out during Phase 1.
Demand that the AI enumerate every single file that will be created or changed, and the rationale for why.
The Goldfish Protocol
STEP 5: THE COMPREHENSION TESTThis is where the magic happens. Start a brand new, empty AI session (the Goldfish) with zero historical context. Give it your Markdown doc and say:
"Read this document and the files it references. Tell me what it's trying to accomplish, and how my system currently works as it relates to this feature."
Do Not Skip This Loop: If the Goldfish cannot explain your system based only on that doc, your doc is missing context. Add the details and repeat until it passes.
§11: Agentic Harnesses for the Win
Harnesses elevate you from the specs to the goal, using intelligence, skills and data.
The Goal: Autonomous System Delivery
Elevation Engine
The Specs (What)
spec.md constraints.
query-watch.skill.
fifa_catalog.json.
§12: The Shift Left
Design judgments are no longer downstream. We are forcing micro-decisions into documentation before a single component is rendered.
Designer ships Figma → Engineer interprets spacing → QA catches misalignment → Cycle repeats.
Designer ships Judgment Doc → Agent synthesizes Spec → UI is rendered correct-by-construction.
"We don't build features. We build the rulesets that allow agents to build features."
Border-Radius Strategy
"All outer containers must inherit parent curvature minus 4px padding to maintain visual concentricity."
Luminance Contrast
"Active states should not exceed 85% luminance to prevent eye fatigue in dark-mode technical environments."
§13: Judgement Belongs to the Humans, So Don’t Be Lazy
100X Velocity // Zero-Trust Review
AI generates logic at 10,000+ tokens/sec. Rigorous human review is our only defense against high-entropy synthetic slop.
Senior Mentorship // Training the Skeptic
Seniors must train juniors to interrogate and critique AI output. We don't need passive prompters—we need rigorous architects.
§14: The Execution Sequence
[MEM] Allocation restricted to 256MB...
[NET] Outbound egress denied...
[CPU] Cycle monitoring active...
[LOG] Anomaly detected in slide_14_logic...
§15: CONTAINMENT AND THE BLAST RADIUS
In a world of synthetic code, execution must be adversarial. We do not trust the generation; we contain it. Every block of code runs in a disposable sandbox, where its "Blast Radius" is monitored in real-time.
Hypervisor-level segregation for every design-to-code iteration.
Real-time resource exhaustion monitoring and automatic kill-switches.
§16: Moving towards Self-Healing and Self-Evolving Software
System failures and runtime friction are no longer human pager alerts—they are deterministic feedback signals. When a UI breaks or an assertion fails, the system intercepts the error, diagnoses the root cause against the spec, patches the logic, and redeploys autonomously.
From Reactive Repair to Proactive Evolution
Beyond immediate self-healing, software begins to evolve continuously against production telemetry. By observing real-world user workflows and drift patterns over time, agentic loops propose architectural refinements directly to the specification stack, re-bootstrapping cleaner, faster iterations automatically.
§17: The Self-Referential Engine
We have reached the point of Singularity in Design. The Agent no longer builds the UI for the User—it builds the Agent that will build the next UI. It is an iterative improvement cycle where the Designer's role is not to create, but to define the Initial Conditions of the engine itself.
Thank You. Questions?
Please provide us feedback:
SCAN WITH YOUR CAMERA