Claude, ChatGPT, Gemini. I explained our app’s architecture three times. 😤

One of my first assignments at work was a “Continue with Google” button. Sign in, land on the home page. Simple enough, I thought.

A lot of it was new to me, so I leaned on AI. Gemini to look up how to build it. Codex to work out how those approaches would fit our app. Claude Code to work on the actual code.

Every time I switched windows, I wrote something like this:

The UI is React, and the server handles login. I’m adding Google sign-in. The button is built, and I’m working on getting to the home page afterward. What I’m trying to understand is…

I’d just written that. To a different AI.

Explain the architecture. Explain the plan. Again.

I showed Codex the approach I’d found in Gemini. What needed changing in our frontend, and what belonged on the server? We looked at the existing code and worked out an order.

I had a better idea of where to start. Time to try it in Claude Code.

Except Claude Code hadn’t been in that conversation. Which approach had I picked? What had I worked out? What was I trying to finish today? I wrote it down again.

Then a new problem came up while coding, and I went the other way. Back to Codex, explaining the current state before asking my question.

The answers came quickly. Getting to the point where I could ask took a lot of typing. (I thought this was just how you used these tools.)

The next morning, I wasn’t sure either

Eventually, signing in took me to the home page. Pretty satisfying.

The next day, I sat down and paused. Where was I picking up?

Had I checked whether refreshing kept me signed in? Did signing in take you back to the article you’d been reading? Codex had suggested one more check at the end. What was it?

I opened the Gemini answer, scrolled through Codex, and looked for yesterday’s work in Claude Code.

Three conversations were moving along nicely. I had one login feature to finish.

I gave the planning its own place

I’d been mixing two kinds of work: deciding what to build and in what order, then actually changing the code and checking it.

I started keeping the first part in thrw. I made an “Add Google sign-in” list and recorded what we’d decided to change, what still needed checking, and what was already done. Decisions and progress, rather than every AI answer.

Add Google sign-in
[x] Go to the home page after signing in
[ ] Check that refreshing keeps me signed in
[ ] Return to the article after sign-in instead of the home page

In the relevant to-do descriptions, I kept the short version of the structure—React UI → server login handling → home page—and the changes we’d agreed to make. The first item also said “Test account: sign-in → home page confirmed.” I still needed to test refresh behavior and implement the return to the original article.

That gave me somewhere to start the next morning. I could look at it instead of remembering which conversation held which part of the work.

Then I connected thrw to both Claude Code and Codex through MCP, so each could read and update my lists and their descriptions.

In a new conversation, I started with:

Read my Add Google sign-in list in thrw, including the item descriptions. Check where I got to, then let’s work on what’s still open.

Instead of retyping the app structure and the plan, I asked it to read what I’d left behind. Claude Code checked the list, then looked at the actual project code to continue.

Codex knew what I’d finished in Claude Code

I checked that refreshing kept me signed in. Before moving on, I asked Claude Code:

Refreshing keeps me signed in; I checked it. Mark that item done and note that I used a test account. I haven’t fixed returning to the article after sign-in yet.

I checked the update Claude Code reported. Two items marked done. Returning to the article was still open.

This time, I asked Codex, with thrw connected:

What do I still need to check for Google sign-in?

Codex read the same list and pointed out that returning to the article after sign-in was still open. I didn’t have to explain what I’d just finished in Claude Code.

Codex was reading the test note Claude Code had left. Oh. This was a to-do app for me, and also a shared database for my AIs.

Decisions and progress that used to live inside separate conversations now had a common place to read from and write to.

That felt good. Work I’d done with one AI was finally useful to the next one without another explanation from me.

I left the MacBook behind. The work was on my phone.

The UX really clicked when I stepped away from my desk.

Later, I worked on our company’s careers page: new team photos, job listings, and Apply buttons. After a morning working with Claude Code, I went out for lunch. A teammate messaged: “Can we share the careers page today?”

The photos were updated. The application links worked. Had I checked it on a phone, though? I wanted to see the status before saying it was ready.

My MacBook was back at my desk. I didn’t want to scroll through a long Claude Code session on my phone.

I opened thrw instead.

• Update team photos — done.
• Connect Apply buttons — done. Application form opened from the test page.
• Check the mobile layout — still open.

Right. That’s where I’d left off.

“Photos and links are done. I’ll check mobile before we share it.” Sent.

I hadn’t even opened thrw on my MacBook that morning. I’d worked with Claude Code and asked it to record the progress. It had updated thrw through MCP. On my phone, all of that progress was laid out in a list I could scan.

In the coding conversation, those details were buried between code snippets and edit history. On my phone, I could see what was done and what wasn’t. That was all I needed to answer my teammate.

The next update came from my phone

While waiting for my food, I opened the test page on my phone. A long job title pushed the Apply button off the screen. It had looked fine on the MacBook.

I left a note in thrw’s AI chat.

Add this to the careers-page mobile check: a long job title clips the Apply button on the right. Schedule the fix today from 3 to 3:30. After fixing it, check again with the longest job title.

My MacBook was still back at the office. I didn’t want to carry the problem in my head and explain it later either. I recorded what I’d just seen on the phone.

I reviewed and applied the changes. The mobile-check item now had the bug description, a note on how to test the fix, and a scheduled work slot.

(The work slot appeared in my connected Google Calendar too. I shared that calendar with the team, so they could see when I planned to finish it.)

At three, back at my desk, I opened Codex on the MacBook. A different AI this time.

Read the careers-page list and item descriptions in thrw. Let’s start with the work I scheduled for three today.

Codex read about the clipped Apply button and how to recheck it. The note I’d left on my phone at lunch. It opened the actual page code and started with the layout of the title and button.

I didn’t open thrw separately on the MacBook. Didn’t copy anything from my phone. Didn’t explain what I’d thought of over lunch.

In the morning, Claude Code left progress that I read outside. In the afternoon, Codex read the next steps I’d left outside.

I could leave an update wherever I was working and pick it up wherever I needed it next. Keeping the plan current stopped feeling like a separate chore.

This was the control tower I’d been missing

That was when thrw felt like my control tower: decide what to do, check what’s finished, and make time for what remains.

It had become an interface layer across my AI tools. I read lists and schedules on my phone; connected AIs read and update the same information on my MacBook.

The planning—what to do, why, and when—stays in thrw. I go to Codex or Claude Code to do the implementation. Finished work and newly discovered problems go back into the same list.

I didn’t have to keep the thrw interface open all day either. Whether I was checking my phone or working with another AI on the MacBook, the next step was waiting in the same place.

I switched AIs. The work was still there.

I still research in Gemini. When I pick an approach or find something to check next, I leave a short note in thrw. (Gemini is web-only for me. No MCP connection; I haven’t tried connecting through the CLI either.)

Back in Claude Code or Codex, I ask it to read the same list. Whichever I open, finished work stays finished. Open items stay open. The notes about what I checked are there too.

I liked this more than I expected. Switching AI windows stopped feeling like restarting the work. What I’d done with a different AI yesterday became where I could start today.

Away from the MacBook, my progress was on my phone. Back at my desk, the next steps I’d decided on outside were there for the AI too.

I wasn’t typing “So, the app is built in React…” again.