Posts on preconfiguration.com

Introduction

Tue, 29 Sep 2026 00:00:00 +0000

Ready machines for coding agents: describe what a project needs once, and each agent platform gets a setup file it can read, checked against its rules, with the setup run on a clean machine before any agent starts.

Preconfiguration.com is a project to build that. Its engine, preconfig, is one small program. It reads a short spec, preconfig.yaml, writes the setup file each platform reads, checks the setup files a repository already has, and runs the whole setup on a clean machine to prove it works.

How It Works

Tue, 29 Sep 2026 00:00:00 +0000

The idea. Describe the machine a project needs in one short file. preconfig writes the setup file each agent platform reads, checks the files a repository already has, and proves the setup on a clean machine. The agent doesn’t need to know any of this.

An AI coding agent in the cloud starts every task on a fresh machine. Something has to install the runtime, the packages and the services before the agent can build or test anything, and each platform reads that something from its own file, in its own format. GitHub Copilot’s cloud agent runs a workflow named copilot-setup-steps. Cursor’s cloud agents build a Dockerfile named in .cursor/environment.json. Codespaces and editors read .devcontainer/devcontainer.json. A fresh server reads cloud-init. Other agents take a script in their settings.

Draft and Build Case Study: Five Files Read, One Spec Drafted, Setups Written for Five Platforms

Tue, 29 Sep 2026 00:00:00 +0000

Most repositories already say what they need. A .python-version file names the Python, requirements.txt the packages, a compose file the databases the developers run, .env.example the variables. What they don’t have is that knowledge in the form an agent platform reads, once for each platform.

In the Alpha demo, orders-api is a small Python service with no setup files for any agent. preconfig detect reads the files it has and drafts preconfig.yaml. preconfig build then writes the setup files for five platforms. The draft turned out to be the spec the team had written by hand, line for line apart from its comments.

Hand-Written Setup Case Study: Fifteen Errors in One Service's Agent Setup, None Flagged When It Was Written

Tue, 29 Sep 2026 00:00:00 +0000

A team that uses two or three agents writes the same setup two or three times: once as a Copilot workflow, once as a Cursor environment, once as a dev container. Each file is written at a different time, from a different example, by whoever needed it that week. Nothing checks them against each other, and most platforms say nothing when a file is wrong until an agent tries to use it.

Clean Machine Case Study: Ready in 49.6 Seconds, and a Missing Redis Caught at the Ready Step

Tue, 29 Sep 2026 00:00:00 +0000

A setup file that looks right proves nothing. The only proof is a machine that starts empty, runs the setup, and then passes the project’s own tests. That is what an agent’s cloud machine does every time a session starts, and when the setup is wrong, the agent finds out in the middle of its task, if at all. GitHub’s documentation says that when a setup step fails, Copilot skips the remaining steps and begins working with the machine as it is.

Upgrade Case Study: PostgreSQL 16 to 17 in One Line, With Every Platform's Files Following

Tue, 29 Sep 2026 00:00:00 +0000

Setup files are written once and changed many times. Every upgrade of a runtime or a database has to reach every file that installs it: the dev container, the Copilot workflow, the Cursor environment, the server script. Miss one, and one agent works on a different version from everyone else, which shows up later as a bug nobody else can reproduce.

In the Alpha demo, the orders-api team moves from PostgreSQL 16 to 17. One line changes in preconfig.yaml. preconfig check lists every file that is now out of date, preconfig build rewrites them, and check is clean again.

Next Uses: Six Places Where a Ready Machine Pays Off

Tue, 29 Sep 2026 00:00:00 +0000

The four case studies share one pattern. A machine that starts empty has to become a known, working machine before anyone can do useful work on it, and the knowledge of what “working” means lives in one reviewed file, proven by a test. Coding agents came first because they start from an empty machine many times a day, on several platforms, with nobody watching.

The pattern turns up well beyond coding agents. None of the six uses below has been tested, and none is a goal of the Beta, though some would reuse what the Beta builds. This post sets out what each would ask of preconfig, what already carries over from the Alpha, and what would be new work. It is a map for choosing what to try after the Beta, ideally with the people who run these systems.

Preconfiguration Explained: How One Checklist Gets Every AI Coding Agent's Machine Ready Before It Starts

Tue, 29 Sep 2026 00:00:00 +0000

Preconfiguration is a prototype of a small program called preconfig. It gets a computer ready for an AI coding agent before the agent starts, from one short checklist, for every agent a team uses. Then it proves the computer is ready by running the project’s own tests on it.

That matters because of how coding agents work today. Tools like GitHub Copilot’s cloud agent and Cursor’s cloud agents take a task and do it on a fresh computer in the cloud. That computer starts empty. If nobody has told it what the project needs, the agent has to guess, and it often guesses wrong: it installs the wrong version, can’t start the database, or gives up on the tests and hands back code nobody checked.

The Next Preconfiguration Prototype: A 12-Week Beta on the Agent Platforms Themselves

Tue, 29 Sep 2026 00:00:00 +0000

The Alpha answered one question. Can one short spec be compiled into every agent platform’s setup file, checked against each platform’s rules, and its setup run on a clean machine with the project’s tests? On one Linux machine, with sample repositories, the answer was yes. The next prototype, the Beta, takes on the harder question: do the files work on the platforms themselves, for real repositories, and does a team’s agent fail less often on them?

The Problem Preconfiguration Solves: Coding Agents Start Every Task on a Machine Nobody Set Up

Tue, 29 Sep 2026 00:00:00 +0000

AI coding agents start each task on a blank machine. When that machine isn’t set up, they guess, fail or hand back untested code, and every vendor wants the setup written in its own file.

Agents Are Poor at Doing It Alone

If agents could reliably set up a repository by themselves, the problem would solve itself. The benchmarks say they can’t, yet:

What Sets Preconfiguration Apart: The Machine Layer, Checked and Proven, Across Every Agent Platform

Tue, 29 Sep 2026 00:00:00 +0000

The code that turns one spec into five files won’t set Preconfiguration apart. Converters like it are cheap to write, and others are close. What can is the layer it owns, the proof it gives, and four defenses that are slow to build.

The Layer It Owns

A coding agent’s world has three layers. On top is what it’s told: AGENTS.md, rules, skills, tool settings. At the bottom is where it runs: a GitHub Actions runner, Cursor’s containers, a sandbox company’s virtual machines. In between is the machine itself: which runtimes are installed, which packages, which services are running, and whether the tests can pass there.

Where the Money Is in Preconfiguration: Fewer Failed Agent Sessions and Control Over Every Agent Machine

Tue, 29 Sep 2026 00:00:00 +0000

Preconfiguration is a prototype today, so its business case is a plan to test with customers. Nobody pays for the translation step by itself: compilers like this are cheap to write, and the engine that writes each platform’s file should be free, as most developer tools are. The money comes from teams that run several agents across many repositories, paying for fewer failed sessions, one view of every repository’s agent setup, and control over what agent machines install. Prebuilt machines, so sessions skip the install, come after that. None of it has been priced with a buyer yet.