The Farmer Was Replaced

Introduction

Most games that call themselves "automation" games are really about building a machine out of pre-made parts and watching numbers climb. The Farmer Was Replaced is the rarer thing: a game where the machine you build is a program, written in a real scripting language, in a text editor that sits right next to the field it controls. You are not dragging conveyor belts. You are writing while loops that tell a drone when to water, if statements that tell it which crops are ready, and eventually functions that wrap all of that into something you can call once and forget about. Solo developer Timon Herzog spent more than two and a half years in Early Access refining that idea before shipping 1.0 in October 2025, and the result plays like a game that knows exactly what it is rather than one still hedging between "toy" and "tool."

The premise is a joke that the game takes completely seriously. A farmer has been replaced — by you, or rather by the drone you program — and the entire rest of the experience is about getting that drone to do more with less input from you. It is, structurally, no different from any other idle-automation loop: earn resources, spend them on upgrades, use the upgrades to earn resources faster. What's different is that the lever you pull to make that loop faster is your own ability to write correct code, not a currency you grind for.

The scripting language, and what it actually teaches

The language is a custom interpreter built to look and behave like Python — indentation-based code blocks, the same def, for, while and if keywords, the same basic data types — without claiming to be a full implementation of the language. That distinction matters more than it sounds like it should. Because the syntax is genuinely Python-shaped, skills built here transfer directly: someone who spends a weekend learning to chain conditionals and write a loop that doesn't run forever has learned something real, not a bespoke dialect that only works inside this one game. Because it isn't actually Python, the game can gate its own API — the specific verbs the drone understands, like moving, planting, harvesting and checking a tile's state — behind the same resource-driven unlock system that gates everything else, which is where the design gets clever.

You don't start with access to loops. You start typing single commands, one at a time, watching the drone execute them literally and only when told. The tedium of doing that for more than a few tiles is the entire pitch for why a for loop exists, and the game waits until you've felt that tedium before handing you the tool that removes it. The same pattern repeats for functions, conditionals and eventually more advanced structures used for optimising harvest routes — each new piece of syntax arrives as the answer to a problem the farm has already made you feel, not as an item on a curriculum. It's the single best piece of pedagogical design in the game, and it's also just good game design: a new tool only lands if the player already wants it.

That pacing is also what makes the game work for two very different audiences at once. Someone who already knows how to program can skim the early unlocks and get to the actually interesting optimisation puzzles — squeezing more yield per tick out of a fixed drone count, or later, splitting work across multiple drones running different scripts — within an hour or two. Someone who has never written a line of code before gets the same content at a pace that never assumes prior knowledge, with the farm itself acting as a constant, visual debugger: the drone does exactly what the code says, so a bug shows up as a drone standing in a field doing something obviously wrong rather than as a wall of text in a console. The people this won't work for are the ones who are simply not interested in typing code under any framing, and no amount of clever unlock pacing changes that — the premise is the whole game, and it should be treated as a hard filter before buying, not a detail to discover after.

Progression, the unlock tree and multiple drones

Resources harvested from the farm buy upgrades from a persistent tech tree — more crop types, higher yields, faster drone movement, better debugging tools, and eventually the scripting features described above. The 1.0 release reworked this into a more exponential curve and, more significantly, added support for running multiple programmed drones at once, which turns the back half of the game into a genuine parallelism puzzle: it's no longer enough to write one correct script, you have to think about how several drones running independently should divide the map between them without stepping on each other's work. That's a meaningfully different problem from the early game's "write one loop that works," and it's the clearest sign that the systems were built to support real depth rather than just extending the same idea for longer.

The reward loop is honest about what it's selling. There's no combat, no story, no exploration beyond the shape of your own field — the entire game is the code and the numbers it produces, plus a leaderboard for players who want to compare optimisation strategies against each other. That's a narrow scope, deliberately so, and it means the game's replayability lives almost entirely in whether you enjoy the act of optimising a script for its own sake. Players who do will find a surprising amount of late-game depth in a game that looks, on the surface, like a five-hour curiosity. Players who came for a farming sim with more traditional trappings will find the fields themselves are the least interesting part of the package.

Presentation and interface

Visually, this is a plain game by design — simple low-poly crops, a simple drone, a code editor occupying a meaningful chunk of the screen at all times. Nothing about the presentation is trying to impress, and that's the correct call for what the game is: anything busier would compete with the code for attention. The built-in editor is functional rather than a great one, but the game doesn't force anyone to use it — support for pointing the game at an external editor of your choice is one of its more player-respecting decisions, and it means the interface friction that would normally cap a text-heavy game's appeal mostly disappears for anyone with existing tools they'd rather use.

Final verdict

The Farmer Was Replaced succeeds at something a lot of "educational" games claim and don't deliver: it teaches real programming concepts by making them the actual solution to an actual in-game problem, and it does that without ever feeling like homework. The unlock pacing is the standout — loops, functions and conditionals arrive exactly when their absence has already made itself felt — and the 1.0 additions of a reworked tech tree and multiple simultaneous drones give the systems enough depth to reward players well past the introductory hours. What keeps it from the very top of the scale is scope, not execution: the presentation is intentionally minimal, the game is single-player with no way to share a script or race a friend directly, and the difficulty curve between "simple loop" and the harder optimisation and recursion puzzles is steep enough that a true beginner may need outside help to clear it.

None of that changes what this is: a cheap, finished, distinctive automation game that respects both the player who already knows how to code and the one who's never tried. Anyone who enjoys Wanderer's own approach to progression that keeps working while you're not actively steering it will find something to like in a game built entirely around writing the thing that steers for you.