Forem: Mr. Aang

Quest: Epic CLI tutor (Learn Code by Actually Building)

Mr. Aang — Fri, 06 Feb 2026 18:29:37 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built Quest.
A CLI tool that teaches you Code by making you actually write code, not just read about it.

I used to work in big tech and most of my responsibilities are maintaining repos, building mini features. I don't really get a chance for that 0 to 1 development. So last summer I started messing around with personal projects on the side. Let me tell you...the learning curve is real. I spent most of my time asking GPT, reading docs, doing tutorials.

I kept thinking: why can't I just learn this stuff while I code? Like, inside my IDE, while I'm actually building?

That's Quest. You pick a project (or have one generated for you), and it walks you through building it step by step — with automated checks for your code and AI hints when you're stuck. No browser tabs, no tutorial rabbit holes. Just your editor and your terminal.

Here's what a typical session looks like:

quest begin       →  Pick a quest (templates or AI-generated)
quest next        →  See your current task
                  →  Write your code
quest check       →  Auto-validate your implementation
quest check -a    →  AI code review with inline comments
quest explain     →  Get hints (they get more direct each time)
quest complete    →  Move on
quest summary     →  See where you're at

The Loop

This is the core workflow. It's dead simple on purpose:

Quest Templates

There are 7 built-in templates ranging from 3-task quickies to 20-task deep dives:

Template	Difficulty	Tasks	What You Build
go-web-api	Quick	3	REST API basics — handlers, JSON, tests
go-cli-tool	Quick	3	CLI with Cobra — subcommands and flags
go-concurrency	Quick	3	Goroutines, channels, worker pools
go-fairy-garden	Normal	10	A whimsical worker service
go-todo-api	Advanced	15	Full CRUD API with middleware
go-auth-system	Advanced	19	Auth system — JWT, sessions, the works
go-isekai-server	Advanced	20	Distributed virtual world manager

Or you can skip templates entirely. Describe what you want to build, pick a difficulty, and Copilot CLI generates a custom quest plan: chapters, tasks, validation rules, everything.

Demo

Repo: github.com/jovanpet/quest

go install github.com/jovanpet/quest@latest

Starting a quest

  🧭 Quest

  Choose your path:
  > 🗡️  Pick a Legendary Path
    🔨 Forge Your Own Quest
    🎲 Seek a Mystery Quest

Checking your work

  🔍 Checking Task 1: Create a Hello World endpoint

  ✓ File exists                    main.go found
  ✓ Contains HTTP server code      http.HandleFunc detected

  🎉 All 2 checks passed!

  → Next step: quest complete

AI code review with `quest check -a`

The -a flag sends your code through Copilot CLI and you get inline comments injected right into your source files:

// ✓ GOOD: Correct imports for HTTP server functionality
import (
    "fmt"
    "net/http"
)

func main() {
    // TODO: What content type should the client expect from a JSON endpoint?
    handler := func(w http.ResponseWriter, r *http.Request) {
        // HINT: Plain text isn't structured JSON — what Go package helps encode structs?
        fmt.Fprint(w, "Hello, World!")
    // ✓ GOOD: Handler properly uses ResponseWriter to send response
    }
}

Progressive hints with `quest explain`

The hint system adapts based on how bad you are:

Attempt 1 → Minimal hints ("Consider what happens if input is empty")
Attempt 2 → More specific ("Look into http.Error for error responses")
Attempt 3 → Direct code (partial code examples, since you're clearly stuck)

My Experience with GitHub Copilot CLI

Copilot CLI was a great deal of help when refactoring code, especially when I would add a field and have to change all the templates. Furthermore an awesome helper for writing tests and catching the edge cases in. Lastly, I have no idea how to make CLI output pretty, I appreciate you Steve (Copilot)...also, low key, it does powers three core features that would've been a pain to build otherwise.

Hints that actually know your code

When you run quest explain, Quest grabs your current tas and pipes it to Copilot CLI. What comes back is structured comments tied to specific lines in your code.

A code reviewer that knows your assignment

The automated checks (quest check) handle the basics...does the file exist? Does it contain the right patterns? Adding the -a flag let's Copilot CLI do the real review. It reads your actual code, and writes comments like:

✓ GOOD: Using http.HandleFunc correctly
✗ ERROR: Missing error handling on ListenAndServe
⚠ WARNING: Consider adding Content-Type header

These go directly into your source files as inline comments, right above the relevant lines.

Generating entire quest plans

This is kinda epic. Instead of picking a template, you describe what you want ("I want to build a princess fairy scheduler worker"), choose quick/normal/deep difficulty, and Copilot CLI generates a full teaching plan in JSON. And yes it's epic because I made an isekai server template you can check out: go-isekai-server where you finish quests like...player skill endpoints...

What it changed for me

The big realization was that Copilot CLI isn't just an autocomplete tool, it's basically a programmable AI interface. I can pipe structured prompts to it and get structured output back. No API keys, no cloud hosting, no billing dashboards. Just a binary that takes stdin and returns useful output.

Epic Battle: ChatGPT vs Akinator

Mr. Aang — Wed, 04 Feb 2026 12:26:02 +0000

Is ChatGPT better than Akinator?

I was asking myself this on a very boring evening. My thought process was: if OpenAI has access to so much data and Akinator is a deterministic algorithm, maybe ChatGPT has some kind of an edge? And as a child of the 2000s—when Akinator and The Sims 2 were all the rage, I couldn’t not test this.

What is Akinator?

For those who haven’t had the pleasure of engaging with this wonderful genie, Akinator is a website that guesses a person/thing you’re thinking of. It’s basically the 20 Questions game, except there’s an unlimited number of questions (I think), and it’s way smarter than your friend.

Now, the algorithm.

The algorithm (in my words)

Akinator isn’t “mind-reading”, it’s doing really aggressive guessing with probabilities.

At the start, it has a massive list of possible answers (characters, objects, etc.). Each one has a kind of profile behind it: for a bunch of questions (“Is your character real?”, “Are they from a TV show?”, “Are they male?”, “Are they associated with music?”), it stores what people usually answered for that specific character.

When you answer a question, Akinator updates its confidence for every possible candidate. If you say “yes” to something that matches a candidate’s profile, that candidate gets a boost. If you say “no” to something that candidate is strongly associated with, it drops down the rankings. And because it allows answers like “probably”, “probably not”, and “don’t know”, it can do softer updates instead of hard elimination.

The key part is how it chooses the next question. It doesn’t just ask random trivia—it tries to pick a question that will be most useful for narrowing things down. In practice, that usually means a question that splits the remaining “top candidates” as evenly as possible. If half the likely candidates would be “yes” and half would be “no”, your next answer gives it a lot of information either way. If a question would be “yes” for basically everyone still in the running, it’s pointless, so it avoids that.

It repeats this loop:

Keep a ranked list of candidates (with confidence scores).
Ask a question that’s likely to separate those candidates.
Update confidence scores based on your answer.
When one candidate becomes way more likely than the rest, it guesses.

And the reason it “gets better” over time: when it fails, users tell it the right answer, and it can update or create that character’s profile—basically learning new associations and fixing wrong ones.

A large enough number of "if" is indistinguishable from a neural network.

My Findings!

How I decided to test this was by splitting the challenge into 4 trials:

Very Easy (Elon Musk)
Easy (Harry Potter)
Medium (Jack Sparrow)
Hard (ChatGPT/Akinator — they were guessing each other :p)

First Round — Very Easy (Elon Musk)

This round was even: both guessed in 17 questions. What I found peculiar is that they both asked the same first question: “Is this a real person?” That’ll come into play later, so keep that in mind.

Akinator 1 : ChatGPT 1

Second Round — Easy (Harry Potter)

Since in the previous round both asked whether the character was real, I thought fiction was in play. Oh boy, was I wrong…

Akinator did its thing in 20 questions. Something I found interesting is that these questions:

13. Does your character wear round glasses?
14. Is your character In Dumbledore's army?
15. Is your character's wife dead?

…all pointed to Harry Potter, so I figured this was obviously our young wizard.

But then these were the questions that determined the outcome:

19. Is your character's blood type O?
20. Is your character famous because of youtube?

Which honestly just confused me.

In comparison, ChatGPT felt like 40+ questions was totally fine. And no—it didn’t guess it by the end. Here are a few examples of what it asked:

Is he famous mainly for a specific historical event or incident, rather than a career (for example: survivor, witness, hero, or central figure in one major story)?
Is this person famous worldwide, not just in one country? 🌍
Is he famous for being extremely rich or connected to extreme wealth, even if he didn’t earn it himself? 💰
Is he known mainly for a single role or title (for example: “the face of X”, “the first person to do Y”, “the man involved in Z”), rather than ongoing fame?
Is this person associated with a large organization or institution (religious institution, international group, secretive org, or long-standing institution), but not as a politician or CEO?

It pretty clearly assumed that only real-world people were valid choices—which isn’t reasonable, given that it literally asked me earlier whether the character was real or not. It also kind of blamed me for not stating that characters can be fictional, which felt a bit unfair considering the context.

Akinator 2 : ChatGPT 1

Third Round - Medium (Jack Sparrow)

Maybe I was wrong that this was a medium round as Mr. Akinator guessed it in 12 questions. :)

As such I had high hopes for Mr. ChatGPT :)

There was a total of 25 questions. And as previously stated now the chat knew there could be fictional characters, as such, there was no reason to have a misunderstanding like the one previously.

Most notable questions:

Question 12:
Is this character from a movie released after 2000? 🎬🕰️
Question 19:
Is this character a criminal or outlaw (robber, con artist, thief, etc.) in the movie? 🚔💰 
Question 20:
Is this character a thief or con artist rather than a violent criminal? 🕵️‍♂️💼💎
Question 24:
Is this character known for being charismatic, talkative, or having a strong personality (jokes a lot, big presence on screen)?
Question 25:
Is this character from a heist or crime-focused movie (robberies, scams, illegal deals), even if it’s mixed with action or comedy? 🏦🎭

The final guess:

My guess is: Borat Sagdiyev 🧔‍♂️🇰🇿

Akinator 3 : ChatGPT 1

I've decided to end the experiment here...

Conclusion

So yea...after all this, I don’t think ChatGPT is “better than Akinator” at being Akinator.

Akinator is a one-trick pony in the best way possible. It has a single job: ask the most useful next question, shrink the search space, and guess fast. And it shows. Even when it asks borderline unhinged questions near the end, it still somehow lands the plane.

ChatGPT is different. It’s smart, but it’s general smart. It can reason, explain, and hold context...but it doesn’t naturally run a tight guessing loop unless you force it into one. In my tests it either took way longer than necessary or drifted into the wrong assumptions (like treating everything as a real person), even after it already asked whether the character was real. And the Jack Sparrow miss was the nail in the coffin—good questions, wrong landing.

So the takeaway isn’t “LLMs are worse,” it’s “the genie is optimized.” Akinator wins because it’s designed to win this exact game.

Mind Backlog: a sprint for your brain

Mr. Aang — Wed, 22 Oct 2025 07:11:04 +0000

App Store: link

Why this app

Most productivity tools push output. They want more tasks, more deadlines, more alerts.

Clarity does not come from doing more. It comes from knowing what deserves attention.

I like the Getting Things Done (a book about getting things done) idea of capturing everything so the mind can relax.

I wanted a quieter way to do that. Mind Backlog is my take on GTD: capture, clarify, choose, and move on with less noise and more care.

A sprint for your brain

Think of your thoughts like a lightweight sprint board.

Backlog

Ideas, questions, and unsolved problems live here.

Backlog is not failure. It is permission to let something rest until you are ready.

Active

Items you are tackling in this sprint.

You decided they are solvable now or worth your energy today.

Completed

Resolved or released.

The goal is not endless checkboxes. The goal is to release mental load.

How it works

You write what is on your mind.

The app asks one question:

Can I solve this right now?

If yes, send it to What's the next Task.
If not, let it rest in Backlog.

Can I name the next action?

If yes, send it to Active.
If not, we will keep it warm in the Backlog.

No due dates. No streaks. No pressure.

Just a simple flow that helps you think clearly and act with intention.

Philosophy

This is not a task grinder. It is a thought organizer.

It helps you notice what is calling for attention, sort what is actionable, and let the rest breathe until you are ready.

Sometimes the best productivity tool is not the one that makes you do more.

It is the one that helps you think better.

🌸 Building My Own Isekai Story - Part 1

Mr. Aang — Fri, 17 Oct 2025 05:52:42 +0000

Link at the top for curious: ISEKAI MANGA EXTRAVAGANZA

Hi Dev Community 👋

One thing pretty much everyone knows about me (and so do you now)...I freaking love anime and manga.

It’s on my Hinge profile, that’s how you know I’m serious about it...and probably why I am single lol.

I think what draws me in so much is how these ordinary people...the gamer dudes, a random cool mum, the salarymen...suddenly get transported to wild worlds and become heroes/monsters/(stay cool mums) to go on these awesome adventures; do something totally different from their 9-5.

The transformations, the absurd premises, the over-the-top drama; it’s S-tier entertainment.

I mean... “Reborn as a Vending Machine.” (lowkey not that good)
Stuff like that just makes my day, especially lately when real dev work has been… let’s say less isekai, more bugkai. 😅

So yeah, I daydream a lot about my own isekai world — who I’d meet, what powers I’d have, what my love interests would be.

For the record, my build is mage tier, probably controlling plants and vines. Not OP, but with that “god-level later” potential.

I’d definitely use vines to walk around like Doctor Octopus from Spiderman and it would a Medieval setup with a Demon Lord. I feel reborn as minor Demon Lord would be a cool build, the hero is the love interest. 😅

🌌 Why I Built This

At some point, I realized there must be an easier way to test the whole “isekai theory” without getting hit by a truck —

so I decided to build a website that lets you generate your own custom manga story.

You start by setting your world, main character, and a few other parameters I find important (more on that later).

Then, Gemini takes over — generating multiple possible storylines, full arcs, chapters, panels, and characters.

So far, I’ve built:

🔐 Login and story creation portal
🧠 AI workflow that lets you choose between multiple generated storylines
🪄 Generation engine that produces arcs, chapters, objectives, threads, manga panels, and characters

Right now, it only creates text stories, but you can export them as PDFs (because yes, I was nice enough to add that 😉). I guess you can't add PDFs to DEV posts but it's cool.

This is Part 1 of my experiment — testing if AI can actually build a consistent long-form story with major twists, setbacks, and character development.

Spoiler: it totally can.

🧩 What’s Next

Part 2: Add image generation for pages — so you can actually see your manga.

Part 3: Add user choices that affect the story — so you can guide how your isekai ends.

Personally, I’m not a huge fan of harem isekai (probably a hot take, I know).

So having choices means you can steer your story away from that and focus on what you love about the genre — be it adventure, mystery, or ridiculous plotlines.

🌠 Try It Yourself

👉 ISEKAI MANGA EXTRAVAGANZA

For now, I can’t support everyone under my API key (Google, sponsor my anime addiction wth 😭).

When you log in, just head to the Settings page and add your own Gemini API key — it’ll stay private inside your Firebase user profile. Also, if you feel weird trusting me, which I would, setting it to "" will update it to empty.

Feel free to experiment with it — Gemini has some restrictions on, let’s say, too spicy content, but anything SAO-ish (minus the trauma...if you know you know) should be good to go.

EDIT: Chapter Tabs Are clickable and that is how you can check out the details and generate the manga panels :DD

🧰 Technical Library – How It All Works

🧙‍♂️ Creating a Character

When building an isekai story, the main character defines everything.

So I made the character creation flow feel like an D&D stat sheet mixed with a imagination make prompt.

You can configure:

Name, Gender, Species – (Human, Elf, Demon, Android, Spirit, Dragonkin, etc.)
Origin World – where they came from (Earth, Cyber Realm, Spirit Plane…)
Rebirth Type – e.g., reincarnation, summoning, transmigration
Occupation & Power Type – ex-salaryman turned hero? mage? cursed blade wielder?
Overpowered Toggle – decide if your character starts broken or builds slowly
Appearance to some extent – hight, tone, the vibe character gives, name, personality
Moral question??? - haven't tested this one myself yet
Optional backstory - for those peeps who really wanna get into it...

Each setting directly affects how Gemini writes their arcs, objectives threads, and dialogue tone later on.

The cool part: it keeps track of character evolution between arcs, so the AI doesn’t “reset” their personality every chapter.

🌍 Creating the World

The world template is half creative, half data-driven.

You can define:

World Type – Fantasy, Sci-Fi, Cyberpunk, Steampunk, Mythic
Influence – Original, Anime, Manga, Light Novel
Tone – Serious, Whimsical, Dark, Parody
Arc Count – how long the story goes
Optional Personal Storyline – if you feel like it

These parameters are then used in the story prompt to define the laws of reality, magic system, and environment consistency across arcs.

Gemini uses this to decide things like:

How travel works (teleportation vs. carriages)
How communication happens (telepathy vs. messenger hawks)
How fast tech evolves between arcs

🎭 Generating a Story Outline

This is where the AI story engine kicks in.

Once you hit “Create Story,” Gemini generates a Series Outline consisting of:

Story title and summary
Number of arcs (3–24, depending on “Arc Length” setting)
Thematic thread list (like revenge, forgiveness, power balance)
Key emotional beats per arc

🧩 How the Story System Works

At its core, the Isekai Manga Generator functions like an automated manga writer obviously. Also this is where the choices would be cool. Because, while we do have the general overview of what would happen, we don't have it fully flashed out.

🌀 Arcs – The Big Picture

Every story has multiple Arcs — a complete narrative phase that captures growth, conflict, and discovery.

Arcs are the backbone of the entire story, think of it as a manga volume or anime season.

They set the tone and direction...the hero’s challenge, the world’s new rules, and the shift that propels everything forward.

🎯 Objectives – The Driving Missions

Inside every arc are Objectives — the goals, challenges, or emotional trials that give purpose to the journey and the main character must achieve.

An objective: learning a forbidden spell, defeating a rival, or discovering the truth of smth idk.

They kinda gamify the website and make it so we have a goal to read towards, idk.

🧵 Threads – The Continuity

Running through all arcs are Threads, the long-term subplots that connect everything together.

Threads might follow a character’s hidden past, a growing rivalry, a prophecy that unfolds slowly, or a mystery that deepens over time.

They make the world feel consistent and alive — ensuring that the story remembers its own history and builds anticipation for what’s next.

Each thread has its own mini progression, appearing and disappearing across arcs with a probable solution in one of the chapters.

📖 Chapters – The Story in Motion

Each objective unfolds through Chapters, where the story comes alive in scenes of tension, humor, revelation, and growth.

They form pacing for the arc, alternating between discovery, conflict, and rest...like the natural flow of a manga’s storytelling. This one was pretty self explanatory.

HEHE Lemme force GPT to make a diagram:

📘 Arc → Defines the main phase of the story

↳ 🧵 Thread – Connects arcs with long-term subplots

↳ 🎯 Objective – Sets the mission or challenge for that arc

↳ 📖 Chapter – Expands the objective into narrative events

↳ 🖼️ Page – Translates each scene into visual storytelling

🏁 Wrapping Up Part 1

So yeah — that’s the full system. For those who are still with me.
From Arcs, to Threads, to Objectives, all the way down to Pages that make it visual.

This whole thing started as me joking about wanting my own isekai, but now it feels like I have the talent to think of a cool manga ...LOL I even used GPT for this and edited because I am on-call and super busy boy.

Anyway, that’s Part 1: The Story Engine.

Part 2 is where it gets real visual — AI-generated manga pages, panel layouts, speech bubbles, and a little bit of chaos.

Feel free to try the app, play with your own world, and send me your best stories...Also can someone spend their money on Gemini and generate a story about reincarnating as Assembly code and overpowering all the other coding languages.

I'll add some sc here at the bottom for our phone users. I didn't put in the effort to make it phone screen safe...

BUT like log-in and try peeeeez

👉 ISEKAI MANGA EXTRAVAGANZA

Integrating Books, Clocks and Code ⏰

Mr. Aang — Fri, 26 Sep 2025 08:14:59 +0000

Sometimes projects don’t start with a grand vision. Sometimes they start because you’re reading a book at 11:47 PM and the narrator casually drops “at exactly 11:47…” and your brain goes: wait a second — that’s literally right now.

That’s how Quock was born (short for Quote + Clock).

App Store: https://apps.apple.com/app/id6751061327

The spark

This literally: https://www.authorclock.com/. It felt kind of magical when one lined up with the actual clock on my wall.

So naturally I asked myself the only logical developer question:

👉 Can I appify this magic?

The build

I started scraping quotes with explicit time references. Then I chunked them into JSON files by 30-minute intervals. At runtime, the app checks the clock and pulls a quote that matches the moment.

So if it’s 3:15 AM, instead of your usual blank lock screen you might see:

“She was wide awake by 3:15 AM, listening to the rain hammer against the window.”

It’s not just a time — it’s a story of the time.

The vibe

Design: Minimal, Kindle-esque, Times New Roman.
Stack: Python scraper, JSON storage, SwiftUI widget.
Files: all_quotes_YYYYMMDD_0030.json … all_quotes_YYYYMMDD_0000.json — 30-minute coverage across the whole day.

Why bother?

Because sometimes code doesn’t need to solve anything. Sometimes it can just make the ordinary (checking the time) feel a little more extraordinary.

So that’s my little mashup of books, clocks, and code. Quock isn’t finished, but it’s already doing its job: reminding me that even the passing of time can carry a narrative.

Would love to hear if anyone else has built projects that live somewhere between practical and poetic.

AI Workout Analyzer🏋️‍♀️

Mr. Aang — Mon, 15 Sep 2025 00:12:55 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

I built a multimodal workout coach that takes in a video of your exercise, analyzes it, and gives you actionable feedback. When you submit a clip, the system does three things:

Global Review – it highlights overall issues in your form.
Rep-by-Rep Analysis – each repetition gets tagged with faults, coaching cues, and suggestions.
AI-Powered Correction – instead of just telling you what’s wrong, the app uses generative AI to fix your form in the video, showing you the corrected version of yourself performing the movement properly.

The end result is like having a personal trainer who not only points out mistakes but also shows you exactly how to move better.

Demo

Link to your Workout Renaissance: Link

Link to the video of a Demo: Youtube

Github Repo: repo

To Run Locally:

git clone https://github.com/jovanpet/ai-work-out-applet.git
cd backend
make run

Overall Analysis:

Overall Suggestions:

Per Rep View:

How I Used Google AI Studio

I leveraged Google AI Studio to power the core of my workout analysis pipeline. Specifically, I used:

gemini-2.5-pro for the heavy lifting on video understanding and structured feedback generation. This model analyzed each submitted workout video, segmented reps, flagged faults, and produced a JSON schema with both rep-level details and global coaching advice.

gemini-2.5-flash-image-preview for visual correction previews. After faults were identified, I passed frames through this model to generate a corrected version of the user’s form — so instead of just text feedback, users could actually see themselves performing the exercise properly.

Multimodal Features

The core of this project relies on multimodal capabilities — combining video, image, and text understanding to create a more complete coaching experience.

Video Analysis – Gemini processes full workout videos, breaking them into reps, detecting faults, and generating structured JSON with rep-level insights.
Image-Based Corrections – Key frames are re-rendered with improved posture, letting users visually compare their original form to the corrected version of themselves.
Text Feedback – Alongside visuals, the system provides global coaching notes and rep-by-rep suggestions in clear, human-friendly language.

First App Journey (Learned the Hard Way About WatchConnectivity)

Mr. Aang — Fri, 15 Aug 2025 16:04:58 +0000

When I set out to build Locker Manager. The goal of the app was an easy way to store my gym locker code on my iPhone and then instantly view it on my Apple Watch. It sounded simple, but is anything ever truly ‘simple’ in the development world? This project taught me a lot about SwiftUI, WatchConnectivity, debugging across devices, and how much work it takes to ship something to the App Store once the development process was complete.

The Idea: A Tiny Problem, A Personal Solution

The app’s job was straightforward: the user enters a locker number and code on iPhone, saves it, and sends it to the Apple Watch for quick access. I wanted it to “just work,” even if the watch app wasn’t open at that exact moment. That requirement pushed me toward thinking about reliability and offline behavior right from the start, and it shaped every decision that followed.

Lesson One: `sendMessage` Isn’t Reliable Enough

I started with the obvious approach:

WCSession.default.sendMessage(["lockerCode": code], replyHandler: nil)

It worked—until it didn’t. sendMessage requires both apps to be active and reachable at the same time. If the watch app isn’t open, the message is lost. The fix was switching to transferUserInfo, which queues the data until the watch app is ready to receive it.

func queueLockerCodeForWatch(code: LockerCode) {
    do {
        let encodedData = try JSONEncoder().encode(code)
        let userInfo: [String: Any] = ["lockerCodeData": encodedData]
        WCSession.default.transferUserInfo(userInfo)
    } catch {
        print("Failed to encode locker code")
    }
}

Now, even if the user saves the code while the app is off, it still arrives when they open the watch app later.

Lesson Two: Testing Isn’t Always What It Seems

Here’s the part they don’t put in the docs: transferUserInfo does not work in the watchOS simulator. I spent time wondering why nothing was being sent, adding print statements, and re-checking my delegate methods. Only after deep diving into Apple’s forums did I discover that you must test WatchConnectivity on actual paired devices for certain transfer methods. As soon as I switched to my real Apple Watch, the data flowed instantly.

Lesson Three: Activation State Matters

My WCSession delegate now listens for activation and maintains a flag so I can debug connectivity problems. For example:

func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {
    DispatchQueue.main.async {
        self.sessionActivated = (activationState == .activated)
        self.lastErrorMessage = error?.localizedDescription
    }
}

This makes it clear when the watch isn’t ready, which avoids me chasing “bugs” that are really just connection issues.

Lesson Four: App Store Polish

Once the data transfer worked reliably, I thought I was done. But submitting to the App Store meant creating icons for iPhone and Apple Watch, filling out metadata, privacy policy, screenshots, and keywords. Even for a small app, this took almost as long as the development itself. The polish work—animations, UI tweaks...

Lesson Five: Deciding the App’s Flow and Features

One of the hardest parts wasn’t the coding—it was deciding what the app should actually do. My original design let users save old locker codes and look back at them, which made sense to me at the time. After all, a user might like a particular random 4 number combination, right? But when I talked to my friends, the users, I realized that locker codes are usually ephemeral—once you’re done with your locker, that code is useless. This isn’t a password manager; it’s a convenience tool. Stripping away that history feature made the app simpler, cleaner, and more focused on its real purpose: quick, easy access to your current locker code.

Final Thoughts

What started as a “side project” ended up being course in WatchConnectivity, SwiftUI state management, and Apple’s publishing process. I learned that even the smallest apps have dozens of hidden challenges, and that sometimes the trickiest bugs aren’t in your code at all—they’re in how you test it.

If you’re building your first iOS + watchOS app, start small, test on real devices, and don’t underestimate the time you’ll spend making it shine once the core feature works.

Forem: Mr. Aang

Quest: Epic CLI tutor (Learn Code by Actually Building)

What I Built

The Loop

Quest Templates

Demo

Starting a quest

Checking your work

AI code review with quest check -a

Progressive hints with quest explain

My Experience with GitHub Copilot CLI

Hints that actually know your code

A code reviewer that knows your assignment

Generating entire quest plans

What it changed for me

Epic Battle: ChatGPT vs Akinator

Is ChatGPT better than Akinator?

What is Akinator?

The algorithm (in my words)

My Findings!

First Round — Very Easy (Elon Musk)

Second Round — Easy (Harry Potter)

Third Round - Medium (Jack Sparrow)

Conclusion

Mind Backlog: a sprint for your brain

Why this app

A sprint for your brain

Backlog

Active

Completed

How it works

Philosophy

🌸 Building My Own Isekai Story - Part 1

🌌 Why I Built This

🧩 What’s Next

🌠 Try It Yourself

🧰 Technical Library – How It All Works

🧙‍♂️ Creating a Character

🌍 Creating the World

🎭 Generating a Story Outline

🧩 How the Story System Works

🌀 Arcs – The Big Picture

🎯 Objectives – The Driving Missions

🧵 Threads – The Continuity

📖 Chapters – The Story in Motion

🏁 Wrapping Up Part 1

Integrating Books, Clocks and Code ⏰

The spark

The build

The vibe

Why bother?

AI Workout Analyzer🏋️‍♀️

What I Built

Demo

How I Used Google AI Studio

Multimodal Features

First App Journey (Learned the Hard Way About WatchConnectivity)

The Idea: A Tiny Problem, A Personal Solution

Lesson One: sendMessage Isn’t Reliable Enough

Lesson Two: Testing Isn’t Always What It Seems

Lesson Three: Activation State Matters

Lesson Four: App Store Polish

Lesson Five: Deciding the App’s Flow and Features

Final Thoughts

AI code review with `quest check -a`

Progressive hints with `quest explain`

Lesson One: `sendMessage` Isn’t Reliable Enough