AI-Assisted Coding and Vibe Coding

How building software with LLMs shifts the programmer's job from typing code to specifying intent, supplying context, and reviewing output — across Cursor, Claude Code, and MCP workflows.

The highlights collected here trace a working programmer's-eye view of the transition from writing code by hand to directing a machine that writes it for you. The through-line is not hype but craft: the sources argue that the highest-quality software still comes from a human-plus-LLM partnership, that "vibe coding" is a trap as often as a superpower, and that the real skill has migrated from typing syntax to specifying intent, feeding context, and reviewing what comes back.

From writing recipes to talking to a helper

The framing that anchors everything else is Andrej Karpathy's three-era model of software. The user's own note distills it cleanly: in Software 1.0 "we wrote every single instruction for the computer"; in 2.0 "we showed computers a lot of examples and they figure out the rules themselves"; and now in 3.0 "we just ask the computer to do things and they make up the step."¹ Karpathy's key claim is that something fundamental changed when "neural networks have become programmable with large language models... It's a new kind of computer."¹ The consequence the user underlines: the hottest new programming language is English, which makes communicating precisely — and not having "brainfog" when you explain what you want to the LLM — the new core competency.¹

Everything downstream is a working-out of that shift. If English is the interface, then the programmer's leverage lives in the quality of the specification, the context provided, and the review of the result — not in keystrokes.

Vibe coding and its discontents

"Vibe coding" — accepting AI output on feel, without close reading — is the first thing the experienced practitioners in this collection push back on. Prajwal Tomar's arc is the cautionary tale: "I ditched 'vibe coding.' And suddenly, building with Cursor felt calm again," shipping faster "without burning out."² The veteran C programmer antirez (Redis creator) is blunter, listing "Refuse vibe coding most of the times" as his first practice, because "the maximum quality of work is reached using the human+LLM equation."³

The tension is real: elsewhere in the same collection are giddy reports of vibe coding working — someone with "a graveyard of tightly scoped side projects that i'm just feeding to this thing and it's just spitting out code... that just executes,"⁴ and a demo generating an interactive 3D product app "with zero coding," controllable by hand gestures, via Gemini 3 plus three.js.⁵ The reconciliation the sources suggest: vibe coding shines for throwaway, tightly-scoped, low-stakes builds and collapses for anything you must maintain.

The human+LLM equation: context is king

antirez's positive practices are the most concrete methodology in the set. His rules for extracting quality:

• Provide large context — feed the model everything relevant.³
• "Always show things to the most able model, the frontier LLM itself."³
• "Avoid any RAG that will show only part of the code / context to the LLM. This destroys LLMs performance. You must be in control of what the LLM can see when providing a reply."³

This inverts a common assumption. The instinct to be clever about retrieval — showing the model only the "relevant" snippets — is, in antirez's experience, actively harmful. The human's job is curation of context, and staying in the loop rather than delegating wholesale.

flowchart LR
    A[Specify intent<br/>in English] --> B[Supply full context<br/>whole codebase, no partial RAG]
    B --> C[Frontier model<br/>generates code]
    C --> D[Human reviews<br/>refuses blind vibe coding]
    D -->|refine spec| A
    D -->|agent self-tests<br/>Playwright| C
    D --> E[Ship]

The stacks: Cursor + Supabase + MCP

For full-stack MVP work, a recurring recipe appears: Cursor as the AI-native editor, Supabase as the backend, and MCP (Model Context Protocol) as the connective tissue. Prajwal Tomar calls it "the new way to build," claiming it ships MVPs "5x faster" and automates "80% of repetitive work."⁶ The mechanics the user saved:

The load-bearing idea is MCP: instead of the developer manually shuttling schema and migration files into the prompt, the model reads the live backend natively. It is context-provision (antirez's principle) automated at the tooling layer.

Claude Code and the plugin/skill ecosystem

A second cluster centers on Claude Code, and notably the tone here is un-flashy. Its creator, Boris Cherny, deliberately shows a "surprisingly vanilla" setup: "Claude Code works great out of the box, so I personally don't customize it much. There is no one correct way."⁸ Against that baseline, the community layers lightweight tooling:

• A copy-paste quickstart making the rounds: /model → opus, add the anthropics/claude-code plugin marketplace, /plugin install frontend-design, then shift+tab into plan mode before describing what to build.⁹
• Anthropic's own Cat Wu promoting the frontend-design skill to "make beautiful green field apps."¹⁰
• Brian Lovin's trick of pointing Claude Code at a repo's README to "explore the code base to learn about best practices and patterns... and bring it back into the context" — i.e., have the agent self-configure.¹¹
• Nityesh forking Claude's pptx skill so the agent generates "gorgeous presentations" instead of bland ones.¹²

The model itself is a gating factor on what workflows are even possible. Kieran Klaassen notes that Opus 4.5 let him ship v2 of a "compounding engineering" plugin that "wouldn't have worked a week ago. Previous models would derail after the second parallel" task.¹³ Capability jumps unlock architectures, not just speed.

Prompting is the new craft

If English is the language, prompt design is the syntax. McKay Wrigley's early demo made the point starkly: comparing a default prompt to a specialized one for software generation is "night and day."¹⁴ Two reusable patterns from the collection:

• The senior-dev framing (Aditya Jha): don't ask the AI to "explain like I'm 5." Instead — "You're the senior dev. I'm the intern. Teach me how to build it like you'd expect it in production. Show me the real flow, gotchas, decisions, and best practices."¹⁵ The prompt sets the model's standard.
• Spec-driven building (Dan): prompt Cursor with Sonnet 4.5 to "build and follow" a JSON spec on top of an existing codebase with rules already set up¹⁶ — a concrete instance of the shift from typing to specifying.

Aggregated "golden rules" threads for Cursor and Windsurf circulate as a genre of their own.¹⁷ The pattern across all of these: the artifact you author is the instruction set, and its precision determines the output.

Single-file tools and no-build minimalism

Simon Willison's approach represents a different, quieter mode — using LLMs to build small, self-contained HTML tools. His constraints are pointed:

• "Avoid React, or anything with a build step... I prompt 'no react' and skip that whole rabbit hole entirely."¹⁸
• Load dependencies from a CDN; the fewer the better.¹⁸
• Favor coding agents (Claude Code, Codex CLI) that "can test the code themselves while they work on it using tools like Playwright."¹⁸
• Build paste-transform-copy flows: accept pasted content, transform it, hand it back to the clipboard.¹⁸

The lesson: constraining the model toward simple, dependency-light, self-testing artifacts is itself a technique for reliable AI-assisted output.

Democratization and end-user programming

The furthest-reaching claim is that AI coding dissolves the boundary between developer and user. Every reports that 200 people, "most had never written code," each deployed a working project eight hours into a Claude Code course.¹⁹ Alessandro Aimar's growth hack — find local businesses with bad websites via Google Maps, then rebuild high-conversion sites with a single Replit prompt²⁰ — treats software creation as a commodity input.

Geoffrey Litt gave this its most thoughtful early framing, wondering whether "despite all the hype — we are in fact underestimating the effect LLMs will have on the nature of software distribution and end-user programming."²¹ When anyone can specify and ship, the scarce resource stops being the ability to code and becomes taste, judgment, and knowing what to build.

Where it nets out

The collection lands on a discriminating optimism rather than blanket enthusiasm. Toto Tvalavadze's distinction is the useful summary: he is "quite fond of AI tools that enhance human creativity or productivity, whereas I find purely generative AI tools to be on a spectrum from useless to downright dangerous and misleading."²² AI-assisted coding, done as a partnership, sits firmly on the human-enhancing side — provided the human keeps refusing to fully hand over the wheel. The livestreamed promise of shipping "20x faster"²³ is real, but the recurring insistence across every serious practitioner here is the same: speed comes from better specifying and reviewing, not from stopping to think.

Related

• AI Tools for Knowledge Work and Prompting
• AI and Irreplaceable Human Work
• UI/UX and Visual Design Craft
• Startups, Indie Hacking, and Business Strategy
• Claude Code (Anthropic)
• Cursor
• Overview