The Great Plan Delusion

Your plan isn’t the future. It’s a snapshot with good lighting.

Infrastructure engineers trust a plan. You declare intent, run the command, and read the wall of green and red. It feels like a forecast. It feels like control. A plan makes chaos look predictable. It turns change into a neat list and makes the cloud look calm.

It’s comforting. You can stare at a long diff and believe you’re reading the future. You’re not. You’re reading the past, formatted to look useful.

The Illusion

A plan is frozen in time. It relies on what your state file claims the world looks like, not what is actually there. The moment the plan finishes, it is out of date. Something has already shifted. An instance rotated. A deployment advanced. A provider lagged. The plan has no idea. It can’t.

Yet we treat it like proof. We paste it into pull requests, argue about the diff, and act like a stable plan means the future will follow.

The Ritual

Plans became our weather reports. We know they are wrong, yet we check them anyway. We regenerate them before meetings. We attach them to pull requests as if they were legal records. Some teams even gate production changes on plan diffs, as if approval equals prediction.

Everyone has run a plan twice in a minute and seen two different results. Everyone has hit apply and watched something unrelated break. We know this, yet we keep trusting the process and rely on it because we have no better option.

The Time Problem

The plan is not lying. It is stuck in a world that moves faster than it can. Between plan and apply, anything can happen. Cloud APIs shift. Events propagate. Locks expire. People intervene. The delay can be tiny. Seconds matter. Infrastructure moves. By the time you confirm the change, the world has already shifted.

The tool cannot see that. So it proceeds. Sometimes it succeeds. Sometimes it breaks something that looked stable. We blame Terraform, Pulumi, or whatever tool we used, but the core issue is the story we created about what a plan represents.

The Safety Theatre

We turned plans into a ceremony. Attach the plan. Collect approvals. Wait for the pipeline. Most people skim for the word destroy. Maybe glance at a tag. Everything else becomes noise.

It looks responsible. It feels like a process, but it’s a performance. We built comfort out of routine. When something breaks, we point to the plan. The plan was reviewed and approved. The pipeline passed. Someone said LGTM. None of this is control. It is a reassurance and adhering to a process of red tape.

The Cost Belief

Plans were meant to support communication. They drifted into documentation. We stopped explaining intent. We attached an artifact and called it collaboration. The plan became the place where context disappears. A diff looks like insight, but it is just a list of guesses. This is how understanding fades.

Plans fail because we ask them to predict a system that refuses to pause. Each plan freezes a moment. The moment never lasts.

Moving Beyond Plans

System Initiative does not generate plans because it does not need them. The system already knows what exists, what changed, and why it matters.

A change set in System Initiative is a collection of proposed edits. It is your set of intentions. It can include new resources, updates, or removals. HEAD is the live state of the world, the current truth that every user sees. In most tools, these two things split the moment you start working. In System Initiative, they stay connected.

Each change set stays current because it is rebased onto HEAD every time the world moves. If something changes in the system, the change set adjusts. It never drifts. It never goes stale.

When you make an edit, the model updates at once. You see what will move, what is stable, and what might break before anything executes. It does not matter if the change set was created a minute ago or last week. You can always compare it to the present. You always see the real difference between your proposal and HEAD.

There is no delay. No gap between plan and apply. No frozen diff pretending to be insightful. You are not reviewing a prediction. You are seeing the actual system, simulated in real time. That is what collaboration should feel like. Not a snapshot. A shared view of what is true right now.

The Future

The next generation of infrastructure tools will not create confidence through dry runs. They need to show what is happening, what is risky, and what is safe in the moment. We do not need better plans. We need systems that understand the present.

Infrastructure will not depend on predicting what might happen. It will depend on seeing what is happening now. The idea of a plan will fade. It will be replaced by systems that observe, reason, and adapt in real time.

That is the end of the delusion. That is the beginning of understanding.