woords — an infinite word game

What I built

woords — an infinite, interconnected crossword for iOS. “A crossword with no edge”: instead of a finite grid, boards connect across an endless plane, generated season by season with their own art direction. Built solo in SwiftUI and shipped through App Store review.

How it works

The core is a shared-apron carry-over mechanic (provisional patent filed): adjacent boards share an edge “apron,” so solving one seeds its neighbors — which is what makes an infinite yet coherent board possible. The client is anonymous-first (play immediately; claim an account later), pulling daily sections from an API and rendering the grid natively.

How I built it

SwiftUI (iOS 17+) against frozen data contracts (a section schema + API OpenAPI) so the app and API evolve independently. Content is generated by a separate tooling pipeline and served by a Node/JS API; Firebase via SPM.

• Verification: a `verify-ios.sh` compile+test gate runs before every change; visual bugs are checked through the real navigation push on a booted simulator (not SwiftUI Preview, whose safe-area differs and yields false passes). The suite runs to hundreds of Swift tests.
• Studio build model: worker agents edit Swift in parallel worktrees; only the main agent compiles — a Swift change is never marked “verified” from a sub-agent.
• Release: a scripted App Store “gauntlet” runs before every major submission.

Questions this project answers

What's it like to own every layer of a product as a solo engineer? You carry the SwiftUI client, the JS API and content pipeline, and the release process all at once — there's no one to hand the hard part to. I managed that by freezing the data contracts between the app and the API (a section schema plus an OpenAPI spec) so each layer could evolve independently without me holding the whole system in my head at every change. Shipping it solo through App Store review is the proof that the breadth is real, not aspirational.

How do you keep quality high when no one else reviews your code? I made verification a gate, not a habit. A `verify-ios.sh` compile-and-test step runs before every change, the suite runs to hundreds of Swift tests, and a scripted App Store "gauntlet" runs before every major submission. When you're solo, the discipline has to live in tooling that can't be skipped, because there's no second pair of eyes to catch what you rushed.

Where did the core mechanic come from, and why file a patent on it? The hard problem in an "infinite crossword" is making an endless board that's still coherent. The answer was a shared-apron carry-over mechanic: adjacent boards share an edge apron, so solving one seeds its neighbors. It was novel enough to be worth protecting, so I filed a provisional patent on the interconnection mechanic.

How do you catch UI bugs in a native app with no QA team? By checking the real thing, not a proxy. Visual bugs are verified through the actual navigation push on a booted simulator rather than SwiftUI Preview — Preview's safe-area differs and yields false passes, so trusting it hides real layout bugs. In the studio build model, worker agents can edit Swift in parallel worktrees but only the main agent compiles, so nothing is ever marked "verified" without a real build behind it.

Results

• Live on the App Store, with seasonal content releases shipping through review.
• Provisional patent filed on the core interconnection mechanic.
• Built and shipped entirely solo — SwiftUI client, JS API + content pipeline, and the release process.