Welcome, Friend

A turn-based tactical grid battle game — the Tenlach DNA meets Pokemon meets chess. Mons called Ouips have 2-4 attacks with type advantages, positioned on a grid where positioning and prediction matter as much as power. The game Hot Potato Games was built to ship.

The Potatuhs Shopify storefront — where the brand meets commerce. Merch, print-on-demand products, and the branded shopping experience built on Shopify Hydrogen. The ecommjs bootcamp project from 2018 predicted this. Seven years from learning e-commerce to running a store.

The final form of Crew Queue — the music crew matchmaking concept that has persisted across three iterations (queue-cloud-functions, Queue frontend, Crew Queue v2). Domain owned, plan in mind, deployment waiting for the Potatuhs ecosystem to stabilize. The idea that will not die, currently in its most patient phase.

The literary division of Potatuhs — a platform for distributing all potato-related written content. 101 Potato Haikus, Odie's Epic, Scary Stories from the Potato Shack, The History of the Potato, and whatever comes next. The proof that potatoes are a viable literary genre.

Potatocore.com is the website, potatocore.mp4 is the YouTube channel. My personal brand within the Potatuhs ecosystem — periodic updates on the entire operation, delivered from slightly outside the fold. The media arm that documents the journey while being part of it.

The research arm of Potatuhs — a publication and survey platform focused on market research for industry professionals. Collects survey responses via Formspree, publishes findings, and provides the data backbone for strategic decisions across the Potatuhs ecosystem.

The Hot Potato Games web hub — an Angular platform meant to feel like a modern, crypto-integrated AddictingGames.com. Hosts trivia, Code Words, Sod Tori, and more games under one roof. The gaming division's digital home and the catalog model fully realized.

Quickly spun up csorts.com for FoCoMX 2026 — a web app that puts festival artists front and center, letting visitors preview the ones on Spotify directly in the browser. Built fast for a real event. The runbook that made this should be in the hands of every festival planner.

The primer app — a learning tool that gives you definitions, lets you chat with AI about any concept, and has a feature where the AI prompts itself with intelligent follow-up questions so you can watch simulated experts go back and forth on a topic. The evolution of the Words vocabulary app into something much more ambitious.

The sixth HPG Swift package — authentication for logging into the Hot Potato Games ecosystem. The SDK family grows: Crypto, Models, Repositories, Moderation, Design, Auth. At this point, the HPG SDK has more packages than the HPG App Store has apps.

A CocoaPod containing the Hot Potato Games branded launch screen — the infinite carousel of potato assets that plays while the app loads. Helpful for consistent branding across future mobile apps. Sometimes caused crashes. The infinite carousel, as always, is both the brand's signature and its most reliable source of bugs.

The fifth HPG SDK package — this one via Swift Package Manager instead of CocoaPods. Shared design components, thinking I was going to use it all the time. I did not. Five packages for one app. The lesson was learned two packages ago.

The fourth HPG package — content moderation for online games. Born from a real fear: launching a multiplayer game and not regulating conversation, inviting creeps and inappropriate uploads. Moderation is not a feature — it is a responsibility that comes the moment you let strangers interact.

The third CocoaPod in the HPG SDK trilogy — network calls leveraging the models from HPGModelsKit. Three packages (Crypto, Models, Repositories) for one project. The whole package system got pretty ornery. A lesson in when internal package architecture helps and when it is just friction.

Another CocoaPod for Hot Potato Games — this one containing shared data models for interacting with the HPG backend. The companion to HPGCryptoKit, and a lesson in when shared model packages make sense and when they are premature.

A CocoaPod experiment for Hot Potato Games — a Swift package deployed to Apple's CocoaPods registry. Only ever deployed one CocoaPod. A brief look at the CocoaPods ecosystem and how it compares to the other package registries covered in the is_audio_playing entry.

The second app I deployed — the interval timer + note-taking concept that the 2019 Note Timer never finished. StartNote combines timers with structured notes, allows table inserts within notes, and can diff tables with the same name to quickly see progress over time. The idea from 2019 finally shipped in 2025.

An AI-integrated learning platform spun up once — apparently getting traffic despite being broken in a lot of ways. Probably SEO-optimized by accident. Isn't a bad site. A case study in how sometimes things work for reasons you do not fully understand.

Tenlach without multiplayer — strictly level-based, high-score-driven, how far can you get through the gauntlet. The version that should have been built first every single time. A discussion of why starting single-player and adding multiplayer later is almost always the right sequencing.

The real-time Flutter grid combat game — the concept that has persisted across five years and six iterations. Wake up in a potato shack, fight worms of varying levels on a tactical grid, earn new attacks derived from defeated enemies. Instead of Battle Chips, they are Commandments. Super fun to make. Will re-enter development once the Potatuhs ecosystem is off the ground.

Like Potato Pounder but fitness — a potato doing 10 HIIT exercises based on the Spartacus workout, all hand-drawn. Animated a potato doing burpees, mountain climbers, and jump squats. Fun project, pure Potatuhs energy.

Deployed as Habit Planet — an iOS app for recording daily video reflections, tracking habit streaks, and capturing your progress over time. Made it in two weeks because a girl asked "how hard would it be to make this app?" Haven't spoken to her in at least a year. The app is still live.

ijustgotanidea.com — an idea ingestion system backed by 22 microservices, each named after a Hebrew letter. Aleph was ingestion. The rest never went anywhere. A true tragedy of over-engineering: 22 services for a problem that needed a text file.

The namesake game — a real-time multiplayer party game where players pass a hot potato in a circle with backstabbing, temporary alliances, betrayals, power-ups, and debuffs. The game the entire company is named after. A design exercise in maximizing fun through social chaos.

One of the OG Potatuhs games — you control a burlap sack catching potatoes as they fall from the sky. Catch the good ones, avoid the bad ones (instant loss), don't miss any (also loss). Incredibly basic but not horrible. The kind of game that could grow with attention, and proof that the simplest game concepts often have the longest legs.

An 8-directional contact sorting app — swipe contacts in any of 8 directions to categorize them (hot/cold, friend/family, any label you want). Published on the App Store. Future vision: swap the entity being swiped (assets, emails, tasks) and swap labeling with workflow execution for rapid queue processing.

A Flutter animation app where a potato punches a punching bag potato — built to animate some drawings I did. At one point, it was tied to a gamification system: punch the potato the exact right number of times (a random number between 0 and the day's active user count on hotpotatogames.com) and win an HPG award. Silly, fun, and peak Potatuhs.

A simple utility for monitoring and clearing clogged ports — because when you run ad hoc projects all day, ports 3000, 8080, and 5000 eventually all have zombie processes clinging to them. A tiny tool solving a daily friction point.

The first game I released on iOS with raw Swift — started as FlappyTot, shipped as Tater Dash. Almost Flappy Bird, but with swipe-to-dash attacks against birds, beetles, and spuds while blight pursues you. The first Potatuhs game on the App Store. The potato that flies.

What you are looking at right now. The personal website rebuilt from the ground up — originally over-engineered with Appwrite for a portfolio that did not need a database. Now stripped down to its real purpose: a lynchpin that links Brett Owers, the real person, to the Potatuhs ecosystem.

The most technically ambitious Tenlach attempt — a Go game server with Grafana monitoring, opcode-based messaging, rollback netcode, Docker Compose orchestration, and Tailscale for local network testing. Also the most honest confrontation with a difficult truth: some projects require collaboration, and I struggle with that at times.

My company — Owers LLC, at owers.llc. The successor to We Are 101 as a business entity. The website is very behind despite dozens of web apps being deployed since. A meditation on the erosion of projects without constant attention, why maintenance is where the money is, and the business model of vendor lock-in and retainers.

The iOS-native Swift version of AllTheThings — the personal inventory app originally built in Flutter. Same concept, different platform. A comparison of building the same app in Flutter vs. native Swift, and when each platform is the right choice.

A Next.js rewrite of the original brettjosephowers.com CV website. Used it for a while, then sunset it in favor of brettowers.com. The third iteration of the personal brand online — from static HTML to Next.js to the current site. Each version reflected a different stage of development.

A single Python script that turned ChatGPT into a CLI — all it needed was $OPENAI_API_KEY. Stored conversation logs in the filesystem as a simple state management system. Actually super useful when it was made. The precursor to Claude Code and every terminal-based AI tool that followed.

The original Tenlach backend in TypeScript — built before learning Go, because TypeScript was the language I knew. There were aspects I did not like, and the real problem was that I did not understand Nakama well enough to leverage it properly.

A choose-your-own-adventure story engine built with Python and FastAPI. A recollection of the genre that made reading feel like gaming — and a reflection on how branching narratives are fundamentally tree traversal problems that map perfectly to both game design and software architecture.

My first macOS app — a Kanban board for managing projects, built in Swift with significant AI coding assistance. A discussion of Kanban as a project management philosophy, the broader landscape of project strategies, and what features could make this app worth continuing.

The first iteration of Tenlach — a real-time, card-based tactical combat game on a grid, inspired by Mega Man Battle Network. How the game is played, how a grid game is composed in code, and a deep dive into rollback netcode — the networking architecture that makes real-time multiplayer feel fair even with latency.

A repo of recorded brainwave data captured with a Muse EEG headband — everything from herbal recreation to orgasm to playing bongos to scrolling TikTok. Stored and analyzed following an Azure data course. A neuroscience experiment on yourself, and the discovery that gamma waves spike dramatically during orgasm.

The most useful Chrome extension I ever made — right-click any <video> element to adjust playback speed. Before most video players had built-in speed controls, this extension made everything on the internet watchable at 2x. A full-circle return to Chrome extensions, and proof that the best tools solve your own daily friction.

Forked Significant Gravitas' AutoGPT — the project that launched the autonomous AI agent movement. Don't remember why I forked it, but the concept and execution deserve their own discussion. AutoGPT demonstrated that AI could chain its own thoughts, create subtasks, and pursue goals with minimal human intervention. The website is gorgeous. The implications are still unfolding.

My first published Flutter package — a plugin that detects whether audio is currently playing on the device. Needed to be notified when audio was active so a particular operation could kill the noise. A walkthrough of package building and publishing across every major ecosystem: pub.dev, npm, SPM, Maven, and more.

A fork of Data Science Hamburg's PyTorch course — tensors, neural networks, training loops, and the core mechanics of deep learning. Completed the course, understood the concepts, never used PyTorch professionally. The knowledge atrophied. But the mental model of how neural networks learn persisted and informs how I evaluate and use AI tools today.

A Next.js website exploring Bereshit (Genesis 1) in Hebrew — the numeric codes, the letter-level meanings, and the spiritual architecture of the Bible's opening verses. A fascination with origins, encoded meaning, and the layers that surface when you read a text in its original language.

The second Flutter attempt at the music crew matchmaking platform. Still occupies mind real estate years later — the idea refuses to die. This time, a proper architectural breakdown of how a system like this should be built: matching engine, profile graphs, real-time collaboration, and the social infrastructure that turns strangers into crews.

A syllable-counting validation tool that determines whether text follows the 5-7-5 haiku form. Loads a library of syllable counts and checks content with good accuracy. Currently useful as a validation gate for AI-generated haikus — generate daily haikus, validate with the detector, regenerate if they do not pass.

A website built around the Lord's Prayer in Aramaic — Abwoon d'bwashmaya — inspired by the Sermon on the Mount (Matthew 5-7) and Rocco Errico's work on Aramaic translations. Memorized the prayer, loved it, built a site for it. A project driven purely by personal resonance, not market demand.

A web shop built around a phrase from my boss: "Your Understanding, My Understanding, The Same Understanding." It became my license plate (YUMUTSU), a brand pulling in Japanese philosophy, and a shop that made fewer than 10 sales. A lesson in the difference between a concept you love and a concept the market loves.

A cluster of early AI experiments: containers-1 (purpose unknown), blog-1 (automated logging), conversations-1 (simulating adversarial discussion of Google Trends topics), and free-money-1 (a trading bot). Four probes into what AI could automate, each teaching something different about where AI adds value and where it does not.

My first app I thought would actually go somewhere — it didn't. A push notification vocabulary builder powered by ChatGPT's API. Subscribe to topics you care about, and receive daily push notifications with new words contextualized to your interests. The idea was solid. The distribution was not.

A fork of the Dart language samples. No idea what this was for or what I was thinking. Some repos exist as evidence that you were alive and coding on a particular day, and nothing more.

The Flutter frontend for the card game platform — connected to Firebase Firestore for real-time game state. The flagship game: Setback, a trick-taking card game with bidding, trump selection, and strategic discarding. A deep dive into the rules of Setback and why traditional card games are perfect candidates for digital adaptation.

A Flutter app for cataloging every item in your vicinity — personal supply chain management. Track what you own, share items with family and friends, evaluate stored wealth, and connect with locals who own the same things. The idea of making the physical world as searchable as the digital one. Never came to fruition.

A collection of shell scripts that auto-generate Flutter BLoC scaffolding — states, events, blocs, dashboards, widgets, repositories, and mocks — all linked and properly named from a single command. The precursor to AI-driven code generation, and a case for why scripting is an essential skill for any modern developer.

A login broker service built in Java for BlueFCU (a credit union) — one of my first backend jobs in the fintech space. The broker handled the logic of slowly migrating users from the old online banking platform to the new one during login, seamlessly routing each user to the correct system without them knowing a migration was happening.

A whitelabel Flutter app template — built to pull down whenever client work came along. The client work never officially happened, but the template exists. A discussion of whitelabel architecture, why having a starting point matters, and how AI has changed the "client-ready starter" equation entirely.

A Go backend for a mobile card game platform — play card games with friends on your phone. Works locally, never deployed. A hard look at the three chasms of backend development: building it locally, deploying it for real, and scaling it under load. Plus the brutal reality of testing multiplayer as a solo developer.

A fork of Vardius' Go API boilerplate — the start of a brief but intense phase of wanting to do everything in Go. Renowned as the optimal server language, Go was the backend for Tenlach, a real-time Mega Man Battle Network-inspired game that never shipped. A look at why Go earned its reputation, what Mega Man Battle Network got right, and the value of languages you explore but never deploy.

A Flutter project whose specific purpose is lost to time — but the name points to something deeper. The practice of regular self-audits: what do I know, what do I want, what are my goals, am I still the person I think I am? After high school, the test was calculus. As a developer, the test is the work itself.

My first (and failed) LLC — formed in Wyoming, originally needed for an EIN to receive payments from KDP, Apple, and Google. Evolved into a vision for an education company: "We Are 101" — dedicated to introductions, because the internet can get you the rest of the way, but someone needs to help you begin. A lesson in business formation, tax identity, and knowing when an entity has served its purpose.

The frontend for the Crew Queue matchmaking platform — a social media app crossed with a music crew builder. Pair up artists, producers, brand managers, merch runners, and influencers into crews that ship real songs. Born from personal experience as a rapper, beat producer, and sound engineer. Eventually swallowed by a bigger vision called 2Dueces.

A Flutter Flame + Tiled multiplayer game where users run around a 16-bit virtual world with friends. Got players moving on screen but never cracked the game server, networking, and infrastructure side. A tour through Flame, Tiled, DNS, Cloudflare, and everything that sits between "it works on my machine" and "it works on the internet."

Forked an Ethereum React Native boilerplate with the intention of building for the Magic Mushroom Clubhouse community. The project never materialized into anything spectacular. An honest reflection on the gap between ambition and ability, the grind of community management, and how a season of failures became the foundation for everything after.

A fork of the Moralis documentation — Moralis being the platform that solved one of blockchain development's hardest problems: indexing on-chain data so you can actually query it. A look at what blockchain indexing is, why it is brutally hard, and the honest reality that skills you do not use for five years atrophy.

A fork of an Ethereum dApp boilerplate during the deep dive into the crypto space — buying bretto.eth, attempting an ENS daily podcast ranking domain names, and exploring whether Web3 identity would become the next frontier. A look at ENS, on-chain identity, and the content experiments that do not survive contact with reality.

A short-lived project with people met in the crypto space — a platform for selling whitelist spots for NFT drops. Dabbled in the space but found most of the value propositions less than impressive. A candid look at the NFT era, what was real, what was not, and how to evaluate hype cycles as a builder.

The first game I ever worked on — you control Earth with a shield while stars encroach, tapping to blow them up and collect stardust. Built in Flutter Flame. Somewhat works, nothing to write home about, but it was the entry point to everything that followed: Burlap Sacker, Potato Pounder, Grid Commander, Tenlach, Hot Potato. Every game in the Hot Potato Games catalog started here.

A fork of mmcc007/screenshots — a CLI tool for automating Flutter app screenshots across devices. A deep dive into the technical challenges of automated testing in Flutter, generating App Store screenshots through auth flows, and navigating Apple's strict but necessary publishing requirements.

A CV portfolio website — the predecessor to brettowers.com. The first time "Brett Owers" existed as a domain on the internet. A lesson in why every developer should own their name online, and how a portfolio site evolves from resume to brand over time.

The first app I ever deployed to the App Store. Originally "Explore The Cell" — an educational app with cell biology illustrations made in Adobe Illustrator, animated in the app. Years later, expanded to ~22 mini-games exploring scales from subatomic particles to infinity. The first thing I shipped that strangers could download.

A first Ethereum smart contract application — a crowdfunding "Fund Me" dApp built while following Dapp University by Gregory. An introduction to blockchain development, Solidity, and the world of decentralized applications.

A repo where Kindle Direct Publishing files were stored — probably not the wisest archival strategy, but a practical one at the time. A deep look at how Kindle Create makes book publishing accessible to anyone, and the honest tradeoffs between self-publishing, agencies, and traditional publishing.

A Flutter app attempting to handle location-based logic using BLoC on the client — logic that should have lived on the server. A hard lesson in where state management belongs, and a tour through the major state management patterns in modern app development.

A mobile app for Array School of Technology and Design — the coding bootcamp that taught me to code but did not have its own mobile app. So I built one. A lesson in self-determination: do not wait for someone to assign you the work that obviously needs doing.

A note-taking app with built-in interval timers — the Pomodoro technique meets a journal. Take notes while a bell chimes your reps. The first attempt at merging focus timers with structured note-taking, complete with a detailed feature spec, contribution guidelines, and a known bugs list. A window into how scope creep turns a simple idea into a project that never ships.

The backend for Crew Queue — an unfinished matchmaking app for assembling music crews by clustering people with overlapping skills and vibes. The cloud functions were supposed to power the matching queue, but the project never got there. A lesson in the gap between vision and execution, and the real engineering behind matchmaking systems.

The first publication: 101 Potato Haikus — a book of haikus about potatoes, published on Amazon. Currently 6 volumes published out of a goal of 101. The starting point of Potato Literature and proof that shipping creative work follows the same principles as shipping software.

A fork of the Google Maps Web Service package — the reason lost to time, but the concept opens the door to a fascinating history of geographic computing, from paper maps to GPS satellites to real-time turn-by-turn navigation in your pocket.

Working with the FlutterFire packages — the official Firebase integration for Flutter. Firebase makes it absurdly easy for a solo developer or small team to get started working in the cloud without managing servers, writing backend code, or configuring infrastructure.

A second attempt at the interval timer concept — better than the original Intervolition Flutter prototype but still mid. The real lesson: the difference between framework-level timers (convenient, inaccurate) and timestamp-based timing against a reliable clock (correct, harder). Why most timer apps are quietly wrong, and what real accuracy requires.

A fork of MarcinusX's Flutter NumberPicker — a scroll-wheel number selector that feels more elegant than a text field or stepper. The reason for the fork is lost, but the component points to a deeper question: when does making an input feel satisfying cross the line into making it addictive? A meditation on the black mirror in our pockets.

A fork of the official Flutter plugins repository — the reason is lost to time, but the concept is not. A deep exploration of what plugins actually are, how they differ from packages, and why plugin development is a genuine avenue for creating value across every platform from VS Code to Slack to Maven.

A fork of the Flutter Carousel Slider package — an attempt to fix something in the infinite scroll behavior that I never quite landed. Ironic, given that the infinite slider became the primary design element of the entire Potatuhs brand. A deep look at how infinite carousels actually work, how infinite feeds like TikTok are built, and what both do to our nervous systems.

A first attempt at building a project-based web application — a blog-style app that taught hard lessons about API key security, environment variables, deployment strategies, and the real process of getting a project off the ground.

A fork of the Flutter Geolocator package — another open-source contribution in the Flutter/Firebase geolocation ecosystem. The real value: a deep understanding of how geographic information systems work, from geohashing and the Haversine formula to R-trees, quadtrees, and Uber's H3 hexagonal index.

A fork of the GeoFlutterFire library to improve documentation clarity — a first open-source contribution. A reminder that the vast ocean of free, open-source code is the greatest learning resource ever assembled, and AI has made it infinitely more accessible.

The first attempt at Intervalition — a customizable interval timer built in Flutter that was never finished. Years later, the same vision was shipped in raw Swift. A lesson in how ideas that stir inside you without being alchemized drain your energy, and how shipping them sets you free.

A collection of coding challenges completed during bootcamp — LeetCode-style algorithm problems and FreeCodeCamp exercises. A training ground for learning to think like a programmer: decomposition, pattern recognition, abstraction, and step-by-step logic.

A JavaScript e-commerce platform built from scratch — cart state management, product catalogs, and checkout flows. A deep dive into what goes into the backend of online stores, and why platforms like Shopify exist.

A vanilla JavaScript DOM traversal tool built as a hands-on exercise for learning how to navigate the Document Object Model — the tree structure that sits between your HTML and the browser. A primer on the methods every web developer should understand before touching a framework.

A browser-based Mancala game built in vanilla JavaScript — inspired by the mini-games of Club Penguin and the magic of the old internet where simple, delightful games lived inside larger social worlds.

An unsolicited website redesign mockup for a local business — a lesson in creating your own opportunities by improving someone else's digital footprint and using it to build real industry relationships.

A pixel-perfect recreation of the Adobe Creative Cloud homepage — an exercise in learning by copying, developing taste through imitation, and understanding why the best creators study the best before finding their own voice.

A quiz application built in C# during the Array School of Technology and Design coding bootcamp. Part of a 10-month curriculum completed in 5 months — the project that led directly to an apprenticeship.

A reference repo created during the Array School of Technology and Design coding bootcamp. Documents the foundational command line, Git, and version control concepts that every developer builds on.

A vanilla HTML/CSS/JS boilerplate with Sass architecture — the canonical folder structure for static websites before frameworks took over. A lesson in scaffolding, and why boilerplates matter more than ever in the age of AI agents.

A Chrome extension that lets you save and restore browser tab sessions — built before browsers natively supported tab saving. A hands-on introduction to the Chrome Extension API and publishing to the Chrome Web Store.