Built with Claude, directed by people
Most of Dead Drop's code is written by Claude, an AI model. People decide what gets built, judge whether it's right and play it. Here's how that works, what the people actually do, and where Claude gets it wrong.
Most of the code in Dead Drop is written by Claude, an AI model made by Anthropic. So are most of the art scripts, the tests and the documents behind them. People decide what the game is, judge whether each piece is right, and play it. We’re saying this in one of the first posts on purpose, so that nothing we publish later reads as hiding it.
You have good reasons to be wary of that. Games made with AI have a reputation for generic art, features that look done in a trailer and fall apart in a match, and nobody who can explain how anything works. Claude can produce work that passes every check and still plays badly, and this post shows where that happened here. It covers how the work is organized, what the people do, the checks the work goes through, and the mistakes Claude makes and how they’re caught.
The project is one week old. Everything below describes how it works on the day this is published.
Who does what
People decide what gets built, rule on trade-offs, look at every visual change, and play the game. There are three of us, middle-aged gamers who love FPS and mil-sim battle royales, from a variety of backgrounds including software engineering.
Claude writes the code, the art scripts, the tests and the docs, and does the research behind them. That includes reading tire-friction tables, measuring real cars from published drawings, and looking up how other shooters handle recoil. It also proposes designs, but a proposal isn’t a decision until a person makes it.
People write very little of the code by hand, and nobody reads every line Claude writes. At this pace nobody could. Claude reviews each agent’s changes before merging them. Automated checks test the result. People judge it through screenshots and play tests.
How a change gets made
Every request goes through the same loop.
A person talks to one main session of Claude. It doesn’t write the feature itself. It turns the request into a complete written brief. The brief says what to build, why, which files and documents matter, what’s already been ruled out and how to check the result. Then it hands the brief to an agent, a separate Claude session that does the work.
Each agent works in its own worktree, a separate copy of the code on its own branch, so several agents can work at once without touching each other’s files. One might be changing the netcode while another builds a house and a third fixes the inventory screen. The main session picks a model for each job. Well-defined work like interface, art and wiring goes to a faster model. Work where a subtle mistake is expensive goes to the strongest one. That covers the shared simulation, lag compensation, what the server sends each player, and anti-cheat.
When an agent finishes, it runs the checks that apply to its work, commits on its own branch, merges in everyone else’s latest work, and runs them again. Agents never push anything to the shared repository themselves. The main session reads the agent’s report and its changes, merges them and pushes them straight away, so nothing finished sits on one machine. Then the checks run again on the combined code, and anything that fails is fixed with a new change. The slower benchmark and performance runs happen at intervals.
Anything visible on screen comes back as screenshots, usually a before and an after from the same spot. One of us looks at them and approves or doesn’t. The screenshot tool runs the real game, not a mock-up, so what gets approved is what you’d see.
Every change also leaves a decision record, a short file that says what was decided, why, and what evidence backs it. There’s one file per decision, so two people can write them at once without conflicts. The quotes in this post come from those records, with spelling and punctuation tidied.
One feature, end to end
Off-road driving shows the loop end to end.
It started with a request. “I think we can tone down what the vehicles can go up off-road … It probably should be close [to realistic].” At the time, the off-roader could drive up a grass slope of about 40 degrees from a standstill, which real tires on grass can’t do.
The agent looked up measured tire grip on asphalt, gravel, dry earth and grass in a vehicle engineering textbook. It set each surface’s grip to those values. It then wrote a test that drives each car up slopes of each surface and checks where it gives up, and captured before and after screenshots of a sedan on a grass hill.
Then one of us drove it. “The vehicles just slow down. I don’t get the sense of tires spinning.” The cars could no longer climb the same steep slopes, but at their limit they simply slowed and hung there. The play test exposed behavior the climbing tests hadn’t checked.
The cause was traction control. It held every driven wheel exactly at its best grip, so the wheels never broke loose. Real cars on loose ground spin their wheels and slide back. The fix let the wheels spin past their grip. The climbing test now checks that a car on a slope too steep for it slides back with its wheels spinning.
The car now behaved right, but you still couldn’t see or hear it. A second change drew the wheels spinning at the speed the engine and gearbox drive them, added a slip sound for loose ground and another for tarmac, and kicked up a little dust. We asked for no performance cost, so the dust comes from a small shared pool of particles and only near the player. A later pass found the slip sound fading in and out over bumps, and fixed it.
Three of those steps were people. A request, a play test and a constraint. Everything else was Claude.
What the people do
The clearest way to show what the people contribute is to quote them.
Taste
On the first day, much of the art was placeholder. The ruling was short.
“We need real art (not the terrible low-poly stuff) for everything.”
That one sentence started a run of rebuilds. The trees, rocks, buildings, both cars, the transport plane and the items you pick up were remade, one category at a time.

Taste also cuts the other way. In the pass on the Scots pines, the agent kept the crowns as sparse as the real trees it measured. One of us said this.
“People are not that familiar with Scottish pines. We don’t have to match them exactly. I’d rather go for the better-looking shot than be super realistic.”
On gear, the rule was that it “must not look anything like” the best-known game in the genre, and should have its own identity. That ruling became the game’s design language for equipment, a fictional issue in muted moss, bracken, heather and peat, with no logos and real dimensions.
Play tests
Most changes that matter came from someone playing the game. A few of them:
- The driver’s gun. “As the driver, I noticed while playing that my gun is still out. I don’t think the driver can shoot, right?” The server already refused the driver’s shots, but the client still played the gunshot and kicked the view when the trigger was pulled. So it felt like the gun was out. Now the gun is put away and the trigger does nothing.
- Scopes. “I’d expect the scope to make it look like I was standing closer. It’s all about realism for the user.” That became a rule for everything the renderer draws at a distance. Through an 8x scope, shadows, trees and grass get the detail they would have if you stood 8 times closer.
- Recoil. “Bug in ADS where it bumps up or down. Supposed to be recoil? But it literally snaps, not like recoil.” That one was Claude’s mistake, and it’s in the section on mistakes below.
- Trees. One of us saw “a fair amount of ‘flashing’ of the trees” walking through a wood. When a tree switched to a lower-detail version, the two versions disagreed about how far away the tree was, so for a moment neither one was drawn.
Saying no
A lot of direction is removal. Some examples:
- “I don’t think we want the truck. It’s a little impractical, since no one is hauling anything.” The truck was cut, and the off-roader became a small pickup with two open seats in the bed.
- “Let’s remove all doors inside a building, keeping only outer doors.”
- “Remove third-person mode (no third person anywhere).”, and after a drive with poor visibility, no glass in any car window.
- Asked whether the zone should show more than the next stage ahead, the answer was “No, it should only show the next zones. The way it’s done is correct.”
Design calls
People have the final say on design. Duos and squads, with downed players who can be revived, were our call. The plane drop is our own design.
We also chose first person only, no glass in vehicles, and a terrain generator that makes only natural landforms. Roads and towns are added in a separate pass. Claude does make provisional choices while it works, as the haze example below shows. Those choices are written down in the decision record, so a person can overrule them.
The checks that keep fast from meaning sloppy
Writing code quickly is the easy part. The hard part is changing core systems every week and finding out quickly when something broke. One command runs the checks, in tiers. Agents run the fast tier before handing work back. The slower tiers add fresh benchmark and performance runs. Passing them all still leaves behavior nobody tested.
- Formatting, linting and about a thousand Rust tests, plus 62 suites that run the actual game headless (no window, no person) and check what it does.
- Determinism hashes. The game’s simulation runs identically on the server and every client, down to the last bit. Recorded runs produce a fingerprint of the whole game state, and a change that alters the simulation without meaning to changes the fingerprint and fails. Changing one on purpose has to be stated and recorded.
- A 100-bot benchmark. A hundred bot clients play a match against the real server over real network sockets, on a clean link and on a simulated internet link with delay and packet loss. Server time per tick, bandwidth per player and how often the client’s hits disagree with the server’s are checked against fixed budgets.
- Art and map validators. Models are checked for colliders that don’t match what’s drawn, windows that should be climbable and aren’t, and parts that float. Every generated map is validated before it’s used. A realism score compares the generated terrain against measured real landscapes.
- Performance runs on one reference machine, compared against recorded baselines.
The art comes from scripts
The art is made by code too. Claude writes Python scripts that run in Blender with no window open. Each script builds a model from parts, bakes its textures and exports it, and validators check the result.
The built models aren’t kept in the repository. They’re rebuilt from the scripts, so a model can be reviewed, rerun and fixed like any other code. We don’t use image generators. The pipeline itself was brought in from an earlier project, with some starting props, so the first week didn’t start from nothing.

The scripts also use third-party material, and it’s credited. That covers scanned bark, rock and plaster textures, the lidar data behind the terrain, and the fonts in item markings. The player’s body is built with MakeHuman’s free assets. Its animations come from Mixamo for now, a stopgap until we have an animator.
What Claude gets wrong
Plenty. Here are the kinds of mistakes we see, with real examples from this week.
A busier test exposes old gaps. One day, after a batch of merges, the benchmark failed 2 of its 114 checks. Client and server disagreed more often than the budgets allow. The cause was two old gaps that a new, busier test map exposed for the first time.
The benchmark’s reference hit prediction ignored vehicles entirely, so every hit on a player in a car counted as a disagreement. Separately, a player pushing a parked car collided with an out-of-date position of it, so the client and the server disagreed about where that player was. The agents whose work exposed the gaps had passed the checks they ran. The benchmark caught it.
One test pushes a parked car over a link with a 60 ms round trip. Before the fix, the client mispredicted its own position in 142 of 180 checks. After it, in none.
Two parts of the game disagree. The sniper rifle’s model and animation were a bolt action, but the simulation treated it as a semi-automatic. Recoil had the same kind of split. The camera eased toward each kick, while the gun, the sights and the reticle jumped a whole kick in a single frame. That jump was the snap we saw.
The first fix smoothed what you see, but during recovery the view and the rounds still disagreed. A second change moved the recovery into the simulation itself, so the view now draws exactly where the next round goes. The rifle is a real bolt action now.
First passes that read wrong on screen. The first wall around the zone’s dead cells was a tall translucent curtain that washed out the view and hid distant terrain. It was retuned to a low line along the ground with a faint band above it. The sedan’s rear took several passes and several rounds of our critique, one of them blunt.
“The back is still pretty bad. I think it’s mostly the bumper, though … In general, when doing this, consider what’s a window and what’s the actual car.”
Reasonable calls that a person overrules. Claude often has to make a call to finish a task. When it added a light distance haze, the agent decided a scope wouldn’t cut through it, an exception to the rule that a scope makes everything look closer. It wrote that down as an open question in its decision record.
The answer was “I feel like the haze should maybe clear like you were standing closer.” Now it does. That’s the point of the records. A call written down can be challenged. A call buried in code usually isn’t.
The benchmark caught prediction errors. Play tests caught the recoil snap, the disappearing trees and the gun that seemed to fire from the driver’s seat. Both find real bugs, and neither catches everything. Feel, readability and taste never fail a test, which is why every visual change needs a person’s approval.
When something gets past both, it goes through the same loop as anything else. Someone reports it and an agent finds the cause. Where the failure can be reproduced automatically, the fix comes with a test that fails without it.
The pace
These numbers come from the project’s own records. They measure activity, not quality. A merged task isn’t the same as a finished feature. But they show what one week of this looks like.
From the first commit to this post, a week later:
- 250 agent branches merged
- 228 decision records
- 794 commits in all
- about 8,100 screenshots captured for review
- about 1,000 Rust tests and 62 headless game test suites
In that week the game went from a design document to a playable test map. It has driving, shooting, destructible buildings, a plane drop and team revives. Another post covers the server’s fog of war in detail.
The limits
Here’s what this doesn’t show.
A week isn’t a game. Fast building isn’t the same as a finished, balanced, fun game. Most of the systems above will change, and so will the art in this post. Some things are designed and not built yet. For example, the server doesn’t yet check at join time that every client renders with the same locked settings.
Play tests so far are small. They’ve been on a 2 km test map. The hundred-player numbers come from bots, and nothing replaces a hundred people trying to break it.
People don’t review every line. People review behavior, screenshots and results, and Claude reviews each change before it’s merged. A bug that no check covers and no player notices can sit there. That’s true of any codebase, but here the volume is higher.
The method costs something too. All of this runs on paid AI models, and the slow checks take real time on real machines.
Why we’re telling you
Players can usually tell when a game was made without care, and they’re right to be skeptical when they hear “AI”. We’d rather you judge the result with the process in plain view. Claude drafted this post. A second AI model critiqued it as an editor. Markup AI checked it against our voice, our terminology and two kinds of reader, from a skeptical technical player to an everyday one. Then people reviewed it before it went up.
There’s a new post every Sunday. Each one covers a system that already exists in the game, and the gap between posts shows how far things move in a week. If you want to see for yourself, the rest of the devlog is the record.