Tag: Software Development

Categories
AI Startups

A New Reason to Launch

“Before you launch, the speed you can build is now mainly limited by your imagination in what you tell AI. After you launch, the AI can watch your users and make improvements on its own.”
— Jared Friedman, Y Combinator

Jared Friedman watches hundreds of founders a year navigate the gap between idea and launched product. He notices patterns the rest of us miss. And what he’s describing above is not an incremental improvement in how software gets built. It is a change in the nature of the advantage.

This is a different kind of liberation than founders have known before.

The old liberation was launch early and the market corrects your wrong assumptions. Humbling, but useful. You were still the one doing the correcting, late at night, rewriting the onboarding flow based on what the data told you.

The new liberation he’s describing is something closer to multiplication. You launch, and now there are effectively more of you. The AI is watching session replays you’ll never have time to watch. It’s noticing the drop-off after step three that you’d have caught in month four. It’s holding the pattern of a thousand user paths simultaneously and asking what they mean. Your imagination seeded the thing. Reality is now feeding it.

That observation redraws the map cleanly. Pre-launch and post-launch used to differ in degree — you knew more after than before. Now they differ in kind. Pre-launch you are the sensing organ. Post-launch you’ve grown new ones.

The founders who feel this most viscerally, I suspect, are the ones building alone or in pairs — the people for whom every previous era of building had a hard ceiling imposed by human hours. They could only read so many support tickets. They could only run so many experiments. The ceiling is lifting and the feeling is of a room getting larger.

The core advice hasn’t changed. Paul Graham was saying “launch early” twenty years ago and it was true then. What’s changed is the reason underneath it — the mechanism that makes it true now is nothing like the one he had in mind.

The advice is twenty years old. There is a new reason and it is brand new. Most people haven’t noticed the swap yet. But they will.

That window does not stay open long.

Categories
AI Stanford

The Unit of Production Just Collapsed

The lecture was a Stanford CS session, AI-native companies, Garry Tan walking through what it now takes to build something. He’d rebuilt his old startup, Posterous, in five days on a modest Claude plan. A thing that once required a team and a runway. He said it matter-of-factly, the way you describe something that’s already obvious to you and hasn’t yet reached everyone else.

The argument Tan and his colleague Diana Hu were making wasn’t really about AI. It was about the economics of effort — specifically, what breaks when the cost of turning an idea into a working thing falls by an order of magnitude.

Their framing: AI-native organizations running as closed-loop systems, agents with access to the real artifacts of work, able to iterate without the error-accumulation that comes from handoffs and headcount. Revenue-per-employee ratios of a million dollars or more, with live examples already in the YC portfolio. Document processing, logistics, voice agents for specialized workflows.

What I kept hearing underneath all of it was a quieter claim: the mental model of what a startup requires is wrong.

Or rather, it’s right about the past and increasingly wrong about the present.

The assumptions embedded in “I can’t do this alone” or “we’d need to hire for that” or “we don’t have the bandwidth” — those are load-bearing assumptions, and the load is shifting.

I have some small version of this — not as a founder, but as someone who retired into curiosity. The blog, the reading, the daily effort to keep up with what’s moving: each one is a practice in staying oriented while the map keeps changing.

What I notice is that the constraint has shifted. It’s not information anymore. It’s not even tools. It’s the capacity to ask better questions of the abundance, to know what matters when everything is accelerating.

That’s the thing I find unsettling, yet also genuinely interesting: the skills that remain irreplaceable are the hardest ones to teach, and the hardest to evaluate in yourself. Knowing what matters. Recognizing when an output is almost right and almost wrong. Setting direction in ambiguous conditions and being willing to be wrong about it. These were always the valuable things. They were just obscured by all the coordination overhead that surrounded them.

The students in that Stanford course were asked to build something called a One-Person Frontier Lab — use the best available tools to extend your own reach over ten weeks. It’s framed as an academic exercise. It doesn’t feel like one.

But I’m not building. I’m mostly watching, and thinking about what this radical new fermentation does to everything downstream — to labor markets, to what a company even is, to how we’ll organize work and meaning when the old unit of production no longer applies. Those are slower questions. But they’re the ones that feel urgent to me.

The old excuses are getting lighter. Not that everything is possible — but that the weight of the usual constraints has changed.

What you choose to build, and whether you choose to build it at all, is more purely a decision than it used to be. That’s either clarifying or terrifying, depending on the day and my mood.

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?”