The Developer's Manifesto for the Age of LLMs

We built the old internet by hand. Line by line. Module by module. That era is ending.

Something profound is happening. For the first time in the history of software, we are not the only entities capable of understanding and generating code. And yet the role of the open-source developer has never mattered more.

This post is a statement of what we must preserve, what we must change, and how we must lead—now that we write software alongside intelligent systems.

A Moment of Clarify

Two days ago, I walked over to my team at Google. I sat down among them. I’m their manager, and many of them are at various points in their careers.

I said:

“Team, I mean this. Something is happening in our business. You need to pay attention. I don’t say this as your manager. I say it as your colleague, someone who’s been writing software for a long time.”

I’m saying the same to you now.

1. The Tools Have Changed. The Responsibilities Haven’t

LLMs can write code. They can write tests, documentation, issues, and propose. But what they can’t do is choose well. They do not judge trade-offs. They do not understand context. They do not share accountability.

We do.

It seems clear to me that our role is no longer just to write functions. Our role is to decide what should be built, what should be changed, and what must be preserved. The machine can act, but we must decide.

2. You Are Now a System Designer, Even If You Never Meant to Be

Using LLMs effectively requires system-level thinking. Prompts are brittle. Instructions decay. The developer who thrives will not be the fastest typist, but the one who can build tooling around the tooling—who can guide intelligent agents through scaffolding, review, and validation.

You must think like an architect now. The sooner you do, the longer you’ll matter.

3. Engineers Must Now Think Like Product Managers

This week, a report asked me, “What should I do?”

I said:

“We need to become Product Managers. Just sooner than we ever thought we needed to.”

That doesn’t mean we stop coding. But it does mean we must define intent, set direction, and validate results. LLMs will handle the middle. Our comparative advantage lies at the edges—where decisions are made, and outcomes are judged.

If you’re not used to thinking about how a system should behave, now is the time to learn. If you’re not used to telling machines — in natural language — what to do in clear, testable terms, now is the time to practice.

4. Open Source is the Front Line of the Shift

It won’t be enterprise vendors who get this right first. It will be the maintainers, the builders, us lone contributors gluing together Python and shell scripts at 2am. Open source is where agent workflows will stabilize, where prompt design patterns will emerge, where safety tooling will be hardened.

If you build in the open, you are already at the frontier. Don’t wait for permission to formalize what you’re doing. Ship it. Name it. Let others copy it.

5. Code is No Longer the Artifact. The Process Is

In the age of LLMs, the how matters more than the what. The prompt, the context window, the handoff to the agents—these become the real intellectual property. Code is ephemeral. It’s a side effect of design and dialogue.

If your project lacks a model for how machines contribute, it might already be behind. The README needs to evolve. The CONTRIBUTING.md file needs to evolve. These are not documents for people anymore. They’re for systems, too.

6. You Must Stay in the Loop. Or You Will Be Replaced by It

LLMs won’t replace you. But someone using one well might.

If you don’t design the pipeline, you’ll be inside someone else’s. If you don’t validate what the agent produces, someone else will—and they’ll get the credit. This is the quiet reality: LLMs aren’t displacing developers; they’re displacing those who don’t adapt.

You aren’t merely writing — or thinking — in prompts. You are the operator of a machine that writes software — perhaps it’s like a compiler, but a lot more so. Think about that.

7. Lead With Clarity. Share With Precision

It’s not enough to adopt the tools. You must name the pattern. Describe your loop. Publish the prompts. Show the boundaries, think about what is working, think about what is not.

We built open source by writing code in public. Now we must build the next layer by designing systems in public.

8. Preserve the Core Values

• Clarity over cleverness

• Truth over polish

• Intellectual honesty

• Judgment over automation

The machines are fast. They are articulate. But they do not care. You must.

Call to Action

• If you use LLMs, document the loop.

• If you’ve built agent infrastructure, name it and release it.

• If you’re still writing everything by hand, ask yourself why. Design documents, proposals, engineering plans. It can all be done faster now — and possibly better.

• If you lead, then teach your contributors, your team, your reports. Tell to think about how to work with the machines.

• And if you’re not sure what to do—start by stating what you’re seeing.

You don’t need to be first. But we need to be clear – this shift is already happening.