Lawn Slide

Flashcards, my first native app, taught me one thing above all: with AI as my pair, I could ship real software on my own. But it left an itch. It was a local trainer, deliberately small, sitting on a shaky pre-agentic foundation. I wanted to know what happened if I removed every one of those limits at once — a real product with depth, built properly from the first commit, with today’s AI coding agents doing the typing while I made every decision.

I also just wanted to build a game. Not a gamified app — an actual puzzle with one honest rule a child could grasp in a single move. You swipe, and a lawn mower slides across the lawn until something stops it, cutting every patch it rolls over. Clear the lawn. That’s the whole game. Everything interesting comes from what you put in its way.

And there was a thesis to prove. Flashcards had convinced me that with modern tooling you don’t need to be a career programmer to ship software — you need to be technically curious and know exactly what you want. Lawn Slide was me betting the same holds at ten times the scale: not a weekend toy, but a complete game — three worlds, hundreds of levels, an economy, in-app purchases, cloud sync and a machine-verified level pipeline. The whole commercial stack, solo.

The core rule is deliberately ruthless. A move only counts once the mower crosses a cell; bumping a rock or the edge costs nothing — that’s misreading the board, not a decision. Because the mower only stops at an edge or an obstacle, you never steer step by step — you plan whole lanes. Finish in the fewest moves and you earn three stars, and “fewest” isn’t my guess: it’s the optimum a solver has proven.

Every tile is a different verb. Water throws you back to where the move began but keeps your progress; a hole ends the run on the spot; mud stops you dead; a bush blocks; a teleporter flings you clear across the board — and then the living things, a sheep that patrols its own path, a mole that surfaces from its hill, gates and switches. And here’s the reuse I’m proudest of: the same rule wears three coats. You mow the Garden, clear the Ice world, sweep the Desert — each world reskins every tile and even renames the action, and each adds its own: slippery snow and ice crystals, quicksand and desert portals. A Tile Glossary teaches all of it the honest way — every tile you can run into, world by world, and what you have not met yet stays locked.

The decision I’m proudest of technically: I never hand-draw a level. Every one of the 256 boards in each world is machine-forged and then proved solvable by a real breadth-first solver that shares the exact movement code the game runs — so the three-star par isn’t a guess, it’s provably the optimal solution. No board ships without a proven path, and the difficulty curve is enforced never to fall backwards. That pipeline is the entire reason three worlds of 256 levels can exist at all: you cannot hand-tune two thousand stars, but you can forge and verify them.

It’s free-to-play, but by rules I set myself. Fuel canisters that only ever charge you for losing — winning is always free. Two currencies, coins and clovers, with exactly one place where premium may buy the base currency, and never the other way around, because otherwise the premium currency means nothing. And the interface is opinionated to a fault: the hub is the ground floor; a red dot means one thing only — something you can collect right now and can afford; settings hide behind a gear, because a place you visit twice a year isn’t a quarter of the app; and the price shelves don’t scroll, because a price list you have to scroll hides half the prices. No analytics, no tracking, no network calls of my own — the app talks only to Apple’s App Store and iCloud.

Lawn Slide is a native iOS app (iOS 17+): Swift, a SwiftUI interface over a SpriteKit game scene, SwiftData for storage, StoreKit 2 for purchases, CloudKit for sync — and not one third-party dependency. The architecture splits hard into four layers, and the movement rules live in exactly one function: the game animates the events it emits, the solver reuses the very same function, so the game, its animation and its difficulty analysis can never drift apart.

What’s in the box: three worlds of 256 levels each, laid out as star-gated ladders; a daily generated garden that’s the same for every player with no server; a fuel economy; daily and weekly quests with a login calendar and a weekly chest; eight achievements; a daily streak; star ratings tied to the solver’s par; six mower skins to drive; and a shop with two currencies and in-app purchases. iCloud sync carries all of it — progress, wallet, mowers, quests, even paid purchases — across every device on the same Apple ID, and it survives a delete-and-reinstall.

The parts I’d point a fellow builder to: the StoreKit layer that credits a purchase exactly once even across an app kill (the transaction id lives in the database, and finish() is always last); the CloudKit merge that takes two offline devices which each created the same save and reconciles them without ever losing a coin; and the two-hundred-plus unit tests that let me refactor any of it without holding my breath — par is checked against replays, purchases are proven to credit once across a simulated restart, the merge is proven to lose nothing.

One honest note on how it was made. Unlike Flashcards, which I hand-assembled with ChatGPT before agentic tools existed, Lawn Slide was built with AI coding agents as the pair: I owned the architecture, made every product call, and read enough Swift to steer hard — but the volume and quality simply wouldn’t exist without them. The interesting inversion is that here the code is the solid part — clean layers, zero dependencies, everything in Git from day one — the exact opposite of my first app.

Lawn Slide is on the App Store — the last mile Flashcards never crossed. Flashcards died on Apple friction, the seven-day resign that kept wiping it off my phone, and it never reached the store at all. This one went the whole way through: the paid developer account, the in-app purchases, the store listing and its screenshots, and the paperwork tail a real release drags behind it. Three worlds are live, and more are already being built.

I was also deliberate about what I didn’t half-build. Game Center and a homescreen widget are left for a later update rather than shipped as stubs — a stub helps no one.

The bigger lesson is the one Flashcards started and this one finished. Flashcards proved I could ship a native app solo; Lawn Slide proved the thesis at scale — that a product person who is technically curious and knows exactly what they want can build genuinely complex software: a provably correct game engine, a commercial purchase-and-sync stack, and a deterministic content pipeline that forges and verifies thousands of stars. The hard part was never the typing. It was knowing what the mower should do when it hits the water — and being stubborn about the answer.

It’s out in the world now — and I’m already forging the next one.