I remembered Shipaton late, entered anyway, and decided to use Name Ninja as the product, 12Quest as the system, and the entire build as the content. The experiment is whether AI can help a solo developer preserve context, stay focused, make better product decisions, actually ship, and reach $1,000 MRR (something I’ve never done before).
Two Weeks Late
I remembered RevenueCat’s Shipaton about two weeks after registration opened.
Not ideal. 😂
But once I looked into it properly, it was obvious this was more than just another hackathon.
Shipaton gives me a very specific window to do something I’ve historically struggled with:
take an ambitious idea, scope it properly, build it, ship it, then actually spend time trying to grow it.
I’ve tried participating before.
In 2024 and 2025, my ambition was comfortably ahead of my ability to execute on it.
That sounds like a technical problem, but looking back, I don’t think it really was.
The bigger problem was structure.
Too many ideas.
Too much context switching.
Not enough clarity around what mattered now.
And a tendency to make the project bigger the second something interesting appeared.
So this year, I wanted to try something different.
Choosing the Right Product
I had two obvious candidates.
Name Ninja was the practical choice.
I’ve already spent roughly two years building an earlier app around the same problem: Remember Names.
That means I’m not entering Shipaton with a random idea.
I already have:
- user feedback
- support conversations
- pricing experience
- App Store experience
- feature requests
- real usage patterns
- and a much clearer idea of what I’d build differently
Then there was 12Quest.
12Quest is the much more ambitious idea.
It’s a system for helping people accomplish goals using AI, RPG-style mechanics, contextual planning, and adaptive guidance.
Much more interesting demo.
Much more dangerous scope. 😂
So the strategic decision became fairly simple:
Name Ninja should be the product I build.
12Quest should be the system I use to build it.
That distinction changed everything.
The Quest Behind the Build
While planning Name Ninja with AI, something slightly weird happened.
The conversation itself started behaving like the product I wanted 12Quest to become.
It was helping me:
- decide which project should be active
- distinguish a real opportunity from a distraction
- define the victory condition
- break the work into phases
- protect the project from scope creep
- adapt the plan when circumstances changed
- and keep the larger objective visible while dealing with day-to-day work
At some point I realized:
I was already using a rough version of 12Quest.
Just not as an app yet.
That created a much more interesting Shipaton experiment.
Instead of building 12Quest and eventually saying:
“Here’s a system that helps you accomplish difficult goals.”
I could potentially spend two months publicly using the system to accomplish one.
Then, if I eventually ship 12Quest, the pitch becomes:
You’ve already been watching it work.
That feels considerably more credible.
Build → Document → Content
There was another problem this solved.
I’ve tried “content creation” around my apps before.
The workflow usually looks like:
- Build something \ ↓
- Stop building \ ↓
- Figure out what to post about \ ↓
- Manufacture some content \ ↓
- Lose momentum \ ↓
Repeat
It turns marketing into a second job sitting beside the actual work.
So for Shipaton, I want to try a simpler system:
Build → Document → Publish
The work itself becomes the source material.
A product decision becomes a post.
A mistake becomes a post.
A pricing experiment becomes a post.
An AI conversation that changes the roadmap becomes a post.
A terrible week where nothing goes according to plan becomes a post.
That doesn’t remove the effort of writing.
But at least I’m not staring at a blank screen asking:
“What content should I make today?”
The answer is already sitting inside the work.
AI Beyond Code
This is the part I find most interesting.
The obvious story around AI and software development is still:
AI writes code faster.
True.
But I think that’s becoming the least interesting part.
A year ago, I wrote about what I called the Third Wave of Coding.
The basic idea was:
- Wave 1:traditional engineers
- Wave 2:self-taught developers
- Wave 3:AI-guided architects
The argument was that as AI becomes better at producing code, the bottleneck moves toward:
- clarity
- communication
- product judgment
- systems thinking
- and knowing what should actually be built
Since then, the models have improved.
But more importantly, the systems around the models have improved too.
They can now:
- hold significantly more context
- work with files, screenshots and media
- plan before executing
- use tools
- review their own work
- operate for longer
- connect to external systems
- and move more naturally from discussion into execution
That matters to me because my biggest problem has rarely been generating ideas.
It’s maintaining enough context across those ideas to consistently execute one of them.
So I’m increasingly interested in AI not simply as a programmer, but as part of the operating system around the programmer.
Context Is the Real Leverage
Imagine giving an excellent engineer a task while withholding half the project history.
They might write beautiful code.
For the wrong thing.
AI has the same problem.
If I repeatedly have to explain:
- what the product is
- what I’m trying to accomplish
- which decisions have already been made
- what I deliberately decided notto build
- what users have told me
- what happened last week
- and why the current task matters
Then a lot of the supposed productivity gain disappears.
So one of the things I’m testing during Shipaton is whether I can build a better layer around that problem.
Persistent context.
Project Codexes.
Structured planning.
Clear active goals.
A record of decisions.
And AI that can surface the right information when it becomes relevant again.
None of those individually sound revolutionary.
Together, they might be.
The Shipaton Experiment
So the experiment now has three layers.
Primary Quest
Build, ship, and grow Name Ninja.
System Under Test
Use 12Quest-style AI workflows to manage focus, priorities, context and adaptation.
Public Layer
Document the real process as it happens.
- Not just the wins.
- The bad decisions too.
- The scope creep.
- The bugs.
- The marketing experiments nobody cares about.
The days when family life, Airbnb work, or something completely unexpected blows up the schedule.
Because that’s the actual problem I’m interested in.
Not:
Can AI build an app?
We already know it increasingly can.
The more useful question is:
Can one neurodivergent person use AI to coordinate the messy system around building something ambitious without losing the plot?
That’s what Shipaton is going to test.
Closing Thought
If Name Ninja grows significantly, great.
If I win something, even better.
But neither is the only useful outcome.
If I come out of Shipaton with:
- a shipped product
- a clearer AI-assisted development system
- a better understanding of distribution
- a body of documented experiments
- and a repeatable way to move from idea → execution
then the experiment worked.
Name Ninja is the quest.
12Quest is the system.
The journey is the content.
Now I just have to actually do it. 🤞