‘Vibe coding’ may offer insight into our AI future — Harvard Gazette

You’ve got a half-baked React component in your browser. It looks fine on a 14-inch laptop, but you open it on a tablet, and the layout collapses into a heap of unstyled divs. You jump into your IDE, spend twenty minutes digging through src/components/Dashboard/Header.tsx, realize the CSS grid is misconfigured, and then try to explain this to Claude Code. You type: "The thing on the top right is broken on small screens."

The model guesses. It fails. You repeat yourself. It’s a tedious, high-friction dance that wastes the very "vibe" you’re trying to ride.

The Vibe Shift

The recent Harvard Gazette coverage of "vibe coding" hits the nail on the head. We’re moving toward a future where the barrier to entry for software creation is lower than ever. You don’t need to be a C++ wizard or a memory-management expert to build a functioning app. You just need to be a good communicator.

But here’s the reality nobody talks about in the lecture halls: prompts are fragile. When you rely on "vibe" to build software, you’re constantly fighting the gulf between what you see on your screen and what the LLM understands about the codebase. If you can’t point to the exact DOM element, the CSS selector, or the component path, the AI is effectively flying blind.

Why Your Prompts Fail

The core issue isn't the AI’s intelligence. It’s your context delivery. If you tell an agent, "Fix the button," you’re forcing the model to infer which button you mean. If your component tree has five buttons, the agent might patch the wrong one, introduce a regression, or hallucinate a fix for an element that doesn't even exist in that view.

Professional engineering demands precision. Even if the Harvard approach champions the "democratization of creation," you still need to be a debugger of your own product. You can’t just rely on the "wow" factor if the production build is fundamentally broken. When the code stops working, "I had a good feeling about this implementation" doesn't fix the stack trace.

Bridging the Context Gap

To make vibe coding actually ship, you have to stop being vague. You need to treat the AI like a senior dev who has never seen your codebase before. That means providing the absolute ground truth: the file path, the CSS selector, and a visual reference.

I’ve been using markagent to handle this heavy lifting. Instead of typing out long-winded, error-prone descriptions of a UI glitch, I just use the shortcut—Cmd+Shift+.—and drop a marker directly on the component. It automatically grabs the React component name, the source file path, and the DOM context. It turns a ten-minute "let me describe this" session into a three-second pointer.

Stop Describing, Start Showing

The Harvard Gazette article notes that vibe coding "privileges people who are strong verbal communicators." That's an uncomfortable truth. If you’re a great coder but a lousy writer, you’re at a disadvantage. If you’re a great writer but don’t know how to inspect the DOM to find the data-testid or the specific module path, you’re also stuck.

This is why I reject the idea that we should just get better at "prompting." We should get better at contextualizing. When you provide the AI with a screenshot, the specific CSS selector, and the viewport size, you remove the guesswork. The agent doesn't need to "vibe" with you; it just needs to read the data.

Iteration vs. Guessing

The biggest time-sink in AI-assisted development isn't the generation speed—it's the loop of correction. If you prompt an agent and it gets it 80% right, you’re happy. But if you have to spend the next hour fixing the remaining 20% because the agent misinterpreted your vague instruction, the "vibe" is dead.

Real iteration looks like this:

1. Identify the point of failure.
2. Capture the exact state of that component.
3. Feed the AI the actual source file location.
4. Let it fix the specific lines of code.

By automating the extraction of these technical details, you turn the AI into a real collaborator instead of a guessing machine. You aren't just "vibing" anymore; you're directing.

Is "Vibe Everything" Sustainable?

Harvard suggests that "vibe coding" might eventually become "vibe everything." That sounds nice, but it ignores the reality of technical debt. When you build stuff with AI that you don't fully understand, you're essentially borrowing speed from the future.

If you don't have a way to quickly annotate, document, and track those AI-generated changes, you’ll end up with a legacy codebase that’s impossible to debug in six months. Don't let your "creative partner" leave you with a mess of spaghetti code. Keep track of what you built, where it lives, and why you built it that way.

The Verdict on AI-First Development

The democratization of software development is a massive net positive. We’re going to see projects built by people who previously thought they were locked out of the tech stack. That’s worth celebrating.

However, don't confuse "easy to start" with "easy to finish." If you want to use AI to ship, you have to respect the underlying architecture. You don't need to be a 10x engineer, but you do need to be a precise one. Use the tools that give the AI the context it needs to actually succeed.

Stop guessing. Start pointing. Your code will thank you.