My AI Argues With Me. That’s the Point.

What happened when I gave my AI partner a persistent memory of my project — decisions, prices, rules, and all the reasons behind them.

Some weeks into building my first app, I floated an idea I thought was new.

My AI partner stopped me. Not with a suggestion — with a receipt. It pointed out that I had already decided the opposite, weeks earlier, and it quoted my own reasoning back at me. The idea I was “brainstorming” would have quietly undone a decision I had made for good reasons and then completely forgotten about.

That moment changed how I work more than any prompting trick I’ve learned.

I should explain the setup. I’m a non-coder in Japan. I built and launched a paid app — Ippin Log, a food log that records a dish by its taste instead of star ratings — entirely by prompting an AI app builder (Bolt.new). A second AI (Muse) works as my strategist, editor, and memory. I wrote about the launch in my first post here.

This post is about the second AI’s real job. It isn’t writing. It’s remembering — and arguing.

Three kinds of forgetting

When you build with AI, everything forgets, all the time, in different ways.

The chat forgets. Every new session starts at zero. The brilliant context you built up yesterday is gone unless you paste it back in, and you only ever paste what you remember to paste.

The builder forgets. My app builder is fast and literal, but it loses the thread. Bundle ten small fixes into one request and the hardest one quietly gets dropped. Ask about something from three changes ago and you’re re-explaining your own product.

I forget. This is the uncomfortable one. I’m the founder, the product manager, and the only researcher — and I still forget what I decided and why. Solo builders don’t have a team to remind them. The decision existed, the reasoning existed, and both evaporated.

A project run by three forgetful parties doesn’t drift because anyone is careless. It drifts by default.

The fix: decisions with reasons, written down

The change was embarrassingly unglamorous. My AI partner keeps a living memory of the project, and the most important entries in it aren’t facts. They’re decisions, stored in a specific format:

What was decided. Why. When.

Some real entries from my project:

  • Price: ¥300/month, ¥3,000/year. Why: low enough that a curious first user says yes, high enough that the product is a business, not a hobby. Decided before launch, charged from day one.
  • Free limit raised from 10 to 40 posts. Why: in a local-discovery app, free users aren’t just free users — their logs are the data that makes the product valuable for everyone nearby. Cutting them off early would strangle the supply.
  • Legal pages don’t print my home address or phone number. Why: Japan’s disclosure rules allow the “provided promptly on request” approach, and I use it. The decision includes the obligation that comes with it: if a request comes, I actually answer it.
  • A standing rule: a fix doesn’t count until it’s verified on the live, published version. Why: AI summaries lie politely. “I fixed it” means nothing; the live number means everything. (This rule has its own scar tissue. I earned it by forgetting to press Publish and then wondering why nothing changed.)

Notice what these have in common. The what is one line. The why is the part that survives.

What pushback actually looks like

Once decisions are stored with their reasons, something changes in the working relationship. The AI stops being a yes-man.

When I propose something that contradicts an old decision, it doesn’t just comply. It flags the contradiction, restates the original reason, and makes me argue against my past self if I want to proceed. Sometimes past me wins. Sometimes I have new information and we update the decision — with a new reason, written down, replacing the old one instead of silently overwriting it.

It also pushes back in the other direction. When a builder’s summary claims a change is done, my partner’s standing instruction — born from that memory file — is to distrust it until the published version proves it. The memory doesn’t just store what I decided. It stores how I got burned, so I don’t have to get burned the same way twice.

A reader of my first post, a fellow AI builder, put it better than I had: an AI that pushes back when you contradict an old decision is worth more than one that agrees with everything, and keeping each decision with its reason is what makes the pushback useful instead of stubborn.

He’s right, and I’d add one thing: the pushback only works because the reasons are there. “We decided X” is an order, and orders get relitigated. “We decided X because Y” is an argument, and arguments can be evaluated. Half the time, Y is still true and I drop my shiny new idea on the spot. The other half, Y has expired — and now the update is a real decision instead of drift.

How to copy this (no special tool required)

You don’t need my exact setup. You need one document and one habit.

  1. Keep one running memory file for the project. Not chat history — a curated document. Decisions, prices, rules, deadlines, and the current state of things.
  2. Write decisions as what + why + date. The why is non-negotiable. Future you (and your AI) will need it to judge whether the decision still holds.
  3. Never silently overwrite. When a decision changes, replace it explicitly and note what changed. A contradiction you can see is a decision. A contradiction you can’t see is a bug in your company.
  4. Re-check numbers instead of reusing them. Counts, balances, and statuses go stale. My memory distinguishes between “decided” (stable) and “measured” (re-verify before quoting). Mixing those two up is how confident, wrong statements get made.
  5. Start sessions by loading the memory, not by re-explaining. The first message shouldn’t be you pasting context from memory — yours or the machine’s.

The tool matters far less than the discipline. A plain text file, maintained honestly, beats a sophisticated system you don’t update.

The honest limits

Memory doesn’t make the AI right. It makes it consistent — and consistency cuts both ways. A bad decision, faithfully remembered, gets defended as faithfully as a good one. That’s why the reasons matter more than the decisions: they’re the part you’re actually allowed to re-argue.

And the memory is only as honest as what gets written into it. My rule is that corrections get recorded too — when I misread a number or call something wrong, that goes in, so the same mistake doesn’t get repeated with confidence next week.

What’s next

The same memory system is now running my second project — a small puzzle game I’m building with AI much more directly in the code — and a third idea behind it. One person, several projects, one memory each. I still can’t write code. What I can do is decide clearly, write the reasons down, and let my partner argue with me when I forget them.

If you’re building with AI and it agrees with everything you say, that’s not a feature. That’s amnesia with good manners.

Give it something to remember. Then let it argue.

— suikeke, indie developer, Japan
X: @suikeke_dev / App: @ippinlog

Ippin Log is live at ippinlog.bolt.host — Japan-first and Japanese-only for now, as I explained in the first post. The build log is the part that travels.

Leave a Reply