Tag: Software Development

Categories
AI Creativity Programming Writing

We Are All Painters Now: The Era of Vibe Coding

For decades, the act of creating software was exactly that: writing. It was a distinctly left-brained, agonizingly precise discipline.

Programmers were typists of logic, translating human intent into a rigid, unforgiving syntax that a machine could understand. A single misplaced semicolon, an unclosed bracket, or a misspelled variable could bring an entire system crashing down.

Building software meant placing one brick after another, working meticulously from the ground up.

In this traditional paradigm, coders were the ultimate embodiment of Annie Dillard’s writer. As she noted in The Writing Life, “Writers… work from left to right. The discardable chapters are on the left.”

When you wrote code, your mistakes, your refactoring, and your discarded logic were all part of a linear, grueling journey. If a feature didn’t work, you had to physically wade back into the text, debugging, reading line by line, and rewriting the narrative of the application. The discarded chapters were the endless hours spent wrestling with a single broken dependency.

But recently, a profound paradigm shift has quietly taken over our screens. We are transitioning out of the era of writing software and into the era of “vibe coding.”

Vibe coding fundamentally changes our relationship with the machine. With the rise of advanced AI coding assistants, we are no longer placing the bricks ourselves; we have become the architects and the creative directors. You don’t write the loop or manually construct the database query. Instead, you describe the feeling, the function, and the outcome. You tell the AI, “Make this dashboard feel more modern,” or “The logic here is too clunky, make it flow faster and handle edge cases gracefully.” You are coding by intuition. You are steering by the “vibe” of the output rather than the mechanics of the input.

Suddenly, Dillard’s other metaphor takes center stage. In the age of vibe coding, we have become painters.

“A painting covers its tracks. Painters work from the ground up. The latest version of a painting overlays earlier versions, and obliterates them.”

When we vibe code, we ask an AI for a functional prototype, and it gives us a canvas. We look at it, test it, and sense whether it aligns with our vision. If it doesn’t quite hit the mark, we don’t necessarily rewrite the code from scratch. We simply prompt the AI to try again, adding a new layer of instruction. The AI paints a new layer of code directly over the old one. The awkward, underlying iterations—the messy attempts at styling, the inefficient logic of the first draft—are obliterated by the newest prompt.

The machine covers our tracks for us. We don’t need to know exactly how the underlying pixels were rearranged or how the syntax was refactored. The final application emerges as a stunning obliteration of its own clumsy past.

As someone who has spent time wrestling with the rigid demands of syntax, there is a strange, quiet grief in letting go of that left-to-right process. There is a deeply earned, tactile satisfaction in building something manually, understanding the precise weight and placement of every line of code. Relinquishing that control can feel like a loss of craftsmanship.

Yet, there is also a breathtaking liberation in this new medium. We are moving from a world of manual construction to a world of artistic curation. The barrier to entry is no longer fluency in a specific, arcane language; it is simply the clarity of your imagination and your ability to articulate your intent.

The next time you sit down to build something digital, notice the shift in your own posture. You no longer have to carry the heavy burden of the writer, agonizing over every word and leaving your discardable chapters on the left. You can step back, look at the whole canvas, and trust your intuition. Let the AI cover the tracks. Embrace the obliteration of the early drafts.

We are all painters now, coaxing the future into existence one brushstroke at a time.

Categories
AI Programming Prompt Engineering Software Work

The Great Inversion

For twenty years, the “Developer Experience” was a war against distraction. We treated the engineer’s focus like a fragile glass sculpture. The goal was simple: maximize the number of minutes a human spent with their fingers on a keyboard.

But as Michael Bloch (@michaelxbloch) recently pointed out, that playbook is officially obsolete.

Bloch shared a story of a startup that reached a breaking point. With the introduction of Claude Code, their old way of working broke. They realized that when the machine can write code faster than a human can think it, the bottleneck is no longer “typing speed.” The bottleneck is clarity of intent.

They called a war room and emerged with a radical new rule: No coding before 10 AM.

From Peer Programming to Peer Prompting

In the old world, this would be heresy. In the new world, it is the only way to survive. The morning is for what Bloch describes as the “Peer Prompt.” Engineers sit together, not to debug, but to define the objective function.

“Agents, not engineers, now do the work. Engineers make sure the agents can do the work well.” — Michael Bloch

Agent-First Engineering Playbook

What Bloch witnessed is the clearest version of the future of engineering. Here is the core of that “Agent-First” philosophy:

  • Agents Are the Primary User: Every system and naming convention is designed for an AI agent as the primary consumer.
  • Code is Context: We optimize for agent comprehensibility. Code itself is the documentation.
  • Data is the Interface: Clean data artifacts allow agents to compose systems without being told how.
  • Maximize Utilization: The most expensive thing in the system is an agent sitting idle while it waits for a human.

Spec the Outcome, Not the Process

When you shift to an agent-led workflow, you stop writing implementation plans and start writing objective functions.

“Review the output, not the code. Don’t read every line an agent writes. Test code against the objective. If it passes, ship it.” — Michael Bloch

The Six-Month Horizon

Six months from now, there will be two kinds of engineering teams: ones that rebuilt how they work from first principles, and ones still trying to make agents fit into their old playbook.

If you haven’t had your version of the Michael Bloch “war room” yet, have the meeting. Throw out the playbook. Write the new one.

Categories
AI Software Work

Lights Out in the Digital Factory

A quiet, modern unease haunts the vocabulary we use to describe invisible labor. Add “ghost” or “dark” to any industry, and suddenly a mundane logistical optimization takes on the sinister sheen of a cyberpunk dystopia.

Consider the “ghost kitchen.” Stripped of its spooky nomenclature, it is merely a commercial cooking facility with no dine-in area, optimized entirely for delivery apps. Yet, the term perfectly captures the eerie absence at its core: the removal of the restaurant as a gathering place, leaving behind only the pure, mechanized output of calories in cardboard boxes. It is a kitchen without a soul.

Now, we are witnessing the rise of the “dark software factory.”

“A dark factory is a fully automated production facility where manufacturing occurs without human intervention. The lights can literally be turned off.”

When applied to software, the concept is both fascinating and slightly chilling. A dark software factory is an automated, AI-driven environment where applications, features, and codebases are generated, tested, and deployed entirely by machine agents. There are no developers huddled around monitors, no stand-up meetings, no keyboards clicking into the night. It is “lights-out” development. You input a prompt or a business requirement, and the factory hums in the digital darkness, outputting a finished product.

Why are these invisible factories so important? Because they represent the ultimate abstraction of creation. Just as the ghost kitchen separates the meal from the dining experience, the dark software factory separates the software from the craft of coding. It optimizes for pure, unadulterated output and infinite scalability. In a world with an insatiable appetite for digital solutions, human bottlenecks—our need for sleep, our syntax errors, our slow typing speeds—are being engineered out of the equation.

But I can’t help but muse on what we lose when we turn out the lights. There is a certain melancholy to this ruthless efficiency. When we abstract away the human element, we lose the “front of house”—the serendipity of a developer finding a creative workaround, the quiet pride of elegant architecture, the human touch in a user interface.

The dark software factory sounds sinister not because it is inherently evil, but because it is utterly indifferent to us. It doesn’t care about craftsmanship; it cares about compilation. As we consume the outputs of these ghost kitchens and dark factories, we must ask ourselves: in our rush to automate the creation of our physical and digital worlds, what happens to the art of making?

The future of production is increasingly invisible. The dark factories are already humming. We just can’t see them.

Categories
AI AI: Large Language Models AI: Prompting

Liquid Software and the Death of the “User”

There is a profound disconnect in how we talk about Artificial Intelligence right now. In the boardrooms of legacy corporations, AI is a “strategy” to be committee-reviewed—a tentative toe-dip into efficiency. But on the ground, among the “AI natives,” something entirely different is happening. AI isn’t just making the old work faster; it is fundamentally changing the texture of what we build and how we think.

In a recent conversation, Reid Hoffman and Parth Patil explored this shift, and the metaphor that struck me most was the idea of software becoming “liquid.”

The Era of Liquid Software

For decades, we have treated software like furniture. We buy a CRM, a project management tool, or an analytics dashboard. It is rigid, finished, and distinct from us. We are the users; it is the tool. But Patil demonstrates a different reality: one where he drops a folder of raw CSV files into an agent like Claude Code and asks it to “look at the data and build me a dashboard.”

Sixty seconds later, he has a fully functional, interactive HTML dashboard. He didn’t buy it. He didn’t spend three weeks coding it. He simply willed it into existence for that specific moment.

This is “vibe coding.” It’s a term that sounds almost dismissive, but it represents a radical democratization of creation. You no longer need to know the syntax of Python to build a tool. You just need to know the “vibe”—the outcome you want, the logic of the problem, and the willingness to dance with an intelligent agent until it manifests.

The philosophical implication here is staggering. We are moving from a world of scarcity of capability to a world of abundance of cognition. When you can spin up a custom tool for a single week-long project and then discard it, the friction of problem-solving evaporates. The “app” is no longer a product you buy; it’s a transient artifact you summon.

Applying the “Vibe Code” Mindset

But how do we, especially those of us who don’t identify as “technical,” bridge the gap between watching this magic and wielding it? The conversation offers a roadmap. It starts by shedding the identity of the “user” and adopting the identity of the “orchestrator.”

If you want to move from passive observation to active application, here are three specific ways to start:

1. The “Interview Me” Protocol

We often stare at the blinking cursor, unsure how to prompt the AI. Hoffman suggests a reversal: Make the AI the interviewer. When you face a complex leadership challenge or a strategic knot, open your frontier model (Claude, GPT-4o, etc.) and say:

“Interview me about this problem until you have enough information to propose a framework or solution.”

This forces you to articulate your tacit knowledge, which the AI then structures into something actionable. It turns the monologue into a Socratic dialogue.

2. Build “Throwaway” Internal Tools

Stop looking for the perfect SaaS product for every niche problem in your team. If you have a messy recurring task—like organizing client feedback or synthesizing weekly reports—try “vibe coding” a solution. Use a tool like Replit or Cursor. Upload your messy data (anonymized if needed) and tell the agent:

“Write a script to organize this into a table based on sentiment.”

Don’t worry if the code is ugly. Don’t worry if you throw it away next month. The value is in the immediacy of the solution, not the longevity of the code.

3. Transform Meetings into Data

Meetings are usually where knowledge goes to die. They are ephemeral. But if you transcribe them (with permission), they become data. Don’t just ask for a summary. Feed the transcript to an agent and ask:

“Who should we have consulted on this decision that wasn’t in the room?”
“Create a decision matrix based on the arguments presented.”

This turns a passive event into an active, queryable asset.

Conclusion

The danger, as Hoffman notes, is the “secret cyborg”—the employee who uses AI to do their job in two hours and spends the rest of the week hiding. But the real win comes from the amplified team, where we share these “vibe coded” tools and prompts openly.

We are entering an age where your imagination is the only true constraint. If you can describe it, you can increasingly build it. The question is no longer “is there an app for that?” but “can I describe the solution well enough to bring it to life?”