The Farmer Was Replaced

Programming games have a credibility problem. Most of them teach an invented language that evaporates the moment you close the window. Zachtronics built a career on gorgeous fake assembly. Human Resource Machine dressed up the same idea in office-drone satire. They are wonderful puzzle boxes, and almost none of what you learn in them survives contact with a real terminal.

The Farmer Was Replaced takes the other road. Solo developer Timon Herzog built a game where the scripting language is a deliberately trimmed dialect of Python, the scripts live on disk as plain .py files, and the syntax you type on day one is the syntax you would type in a job interview. That single decision reframes the entire product. This is not a puzzle game with a coding theme. It is a Python course that happens to have a farm attached, and the farm is good enough that you forget you are studying.

The premise is minimal by design. A farmer has been made redundant. You now write code for the drone that replaced him. It moves across a grid, plants, waters, fertilizes and harvests, and it does absolutely nothing unless you tell it to. There are no levels. Every harvest feeds a research tree that unlocks new crops, bigger fields, extra drones and, crucially, new language features. You literally research the ability to write a for loop.

The game shipped its 1.0 on October 10, 2025 on Steam for Windows and macOS, priced at $9.99. The audience splits cleanly in two: absolute beginners, for whom the concept-at-a-time onboarding is gentler than any tutorial, and working engineers who can treat the late-game leaderboards as a competitive optimization sport. A design that serves both groups without patronizing either is rare, and it deserves the scrutiny of a serious review rather than the usual “cute indie” pat on the head.

• Real Python, gated by research: The language is a Python subset with the same syntax, indentation rules and error messages you would meet in CPython. Variables, loops, functions, lists, dictionaries and sets are unlocked one at a time through the tech tree, so a novice never sees a concept before they need it.
• Continuous progression instead of levels: Every harvest earns resources that buy upgrades to field size, drone speed, new crops and new tools. There is no “level complete” screen, only a farm that gets more complex as your code does.
• External editor and version control support: Scripts are stored as ordinary .py files. Edit them in VS Code, run them through a linter, commit them to git, and the game picks up the changes.
• Algorithmic set pieces: Later crops are puzzles in disguise. Hedge mazes demand pathfinding, cactus fields must be sorted in two dimensions, pumpkins merge into mega-crops only when whole regions ripen together, and sunflowers reward harvesting in a specific order.
• Multi-drone coordination: Late research lets you spawn additional drones running their own code, turning a single-threaded script into a scheduling problem.
• Leaderboards and fast-forward: Timed challenges rank you against every other player by yield per second, and a fast-forward mode lets you test throughput without watching grass grow in real time.

The Loop

The onboarding is superbly paced. You start on a single tile with a drone and one function: harvest(). Run it and you get a piece of hay. Wrap it in while True: and you get hay forever. That is the whole game in miniature, and Herzog knows it. Every subsequent unlock adds exactly one wrinkle. Bushes need to grow before harvesting, so you learn can_harvest() and an if statement. Carrots must be planted and watered, so you learn function arguments and a second resource. The field expands to a grid, so you learn nested loops and coordinate bookkeeping.

What makes this work is the tick economy. Every function call costs time. Movement costs more. A naive script that checks every tile every pass is technically correct and economically ruinous, and the yield counter makes the difference visible in real time. You are not optimizing because a tutorial told you to. You are optimizing because your carrots are coming in slow and the numbers show why. This is the same feedback loop that makes Factorio addictive, except the factory is your own control flow.

The research tree is well paced through the middle game. Unlocking dictionaries right around the time you need to track which tile holds which crop feels like the game read your mind, because it did. Herzog gates language features not by difficulty but by necessity, and the effect is that beginners never feel lost and never feel lectured.

The Language

Veterans will notice what is missing. There are no classes, no exceptions, no list comprehensions early on, no standard library. The subset is intentionally small, and the game’s own execution engine, not CPython, interprets it. That has consequences. Performance characteristics do not map to real Python, so a habit that is cheap here might be expensive in production, and vice versa. The game never pretends otherwise, but nobody should walk away thinking they have learned Python’s performance model.

What they will have learned is far more valuable: how to think in loops, state and cost. The tick model quietly teaches Big O. A player who has sorted a cactus field with a hand-rolled bubble sort, watched the tick counter balloon, and then rewritten it with a smarter approach has internalized algorithmic complexity better than most CS101 students who memorized the table.

For experienced programmers the opening stretch is slow by design. You know what a for loop is and you still have to farm enough hay to buy one. The game offers no “skip the basics” option. That is the correct pedagogical choice and a slightly irritating product choice, and Herzog picked pedagogy.

The Editor Problem

The in-game editor is the weakest component. It has syntax highlighting, automatic indentation and line-level error reporting, and that is roughly the full feature list. There is no meaningful autocomplete, no step debugger, no breakpoints, no watch window. Debugging is print statements and squinting at the drone. For a game whose entire interface is a text editor, this is thin.

The saving grace is that the game does not care which editor you use. Point VS Code at the save folder and the game hot-reloads on save. Put the folder under git and you get history, branches and diffs for free. Once you make that switch the in-game editor becomes a viewer, and the friction largely disappears. But the experience should not require a workaround, and a beginner who does not yet know what VS Code is will spend the whole game in the worse tool.

The Late Game

The back third of the research tree is where the game shows its teeth. Mazes require real pathfinding, and the naive right-hand-rule solution works just long enough to get you invested before the yields tell you it is not good enough. Cactus sorting is a two-dimensional sorting problem with expensive swaps. Pumpkins merge into mega-crops only when a contiguous block ripens at once, which turns a planting loop into a synchronization problem. Then multiple drones arrive and the whole thing becomes a scheduling exercise with shared resources.

The difficulty ramp here is steep — abrupt, even. The middle game hands you one concept per unlock; the late game hands you three at once and shrugs. A beginner who coasted on gentle scaffolding will hit a wall. Herzog could have inserted two or three intermediate crops to smooth the curve, and their absence is the most obvious gap in the design.

The other gap is volume. The research tree does not last especially long, and once it is exhausted the leaderboards are the game. They are genuinely competitive, but leaderboards are a different product than a tech tree. Players who want the dopamine of unlocking things will finish and stop. Players who want to shave milliseconds off a pumpkin script will stay for months. Both groups paid the same price, and only one of them gets a long tail.

The art direction is flat-shaded, low-poly and top-down, and it makes no attempt to be anything more. That is the right call. The visual job here is legibility: you need to see at a glance which tiles are watered, which crops are ripe and where the drone is, and the game delivers that at every zoom level with zero noise. Crops read distinctly, the drone is always visible, and mega-pumpkins swelling across a nine-tile block are satisfying in a way that a spreadsheet never could be.

The UI is a docked editor panel beside the field, with the research tree and output console a click away. It is functional and unadorned. The editor’s font scaling options are limited, which matters on high-DPI displays where the default text runs small.

Performance should be a non-issue by design. A 2D game of this scope is light on hardware, and fast-forward mode skips rendering rather than trying to draw every frame at high speed. The macOS build is native, which is more than most Steam indies can say. There is nothing here that should stress a laptop, and nothing that looks dated on a desktop.

This is a keyboard and mouse game on Steam, full stop. There is no controller support and it would be nonsensical if there were. You are typing code. A physical keyboard is the input device, and the game assumes one.

Steam Deck is technically possible with the on-screen keyboard and a lot of patience, but nobody should buy this expecting to play on the couch. A Deck with a docked keyboard works. A Deck on its own is a demo. There is no native Linux build, so Linux users rely on Proton without official support.

The Windows and macOS builds are functionally identical, which is unusual and welcome. Save files sit in a plain folder as .py scripts, so switching between an office Mac and a home PC is a matter of syncing that folder or letting Steam Cloud handle it. Version control across machines is as simple as any other git repository.

No mobile version exists and none is planned. Ignore any storefront listing that claims otherwise. Typing Python on a phone is a punishment, not a feature.

The Farmer Was Replaced does one thing that almost no programming game has managed: it teaches a real language without ever feeling like school, and it does so with a feedback loop tight enough that the lesson sneaks in while you are busy trying to grow more carrots. The tick economy is the quiet strength here. It turns efficiency from an abstract virtue into a number on screen that you want to see go up, and that single design decision carries the product.

The flaws are real. The editor is underbuilt. The late-game curve needs two more rungs on the ladder. The tree does not offer much of a long tail for players who are not leaderboard people. None of that kills the recommendation, but it does narrow it. At $9.99, this is a solid, worthwhile purchase for beginners and code-writing optimization fans — the two audiences it was clearly built for — and an easy pass for everyone else.