---

I select ‘agent mode’ and submit the prompt. The terminal churrs and green blocks of code pour onto the screen — frontend components, controllers, environment variables, everything. Less than a minute has passed. The prototype actually works.

“This is incredible,” I think. And so enter the labyrinth.

---

1.

I move slowly at first, not from fear, but to admire the pristine folders and files. The technology seems to have come such a long way.

“Ah. I didn’t ask, but he’s remembered to add that module too.”

Lured by new knowledge, I move deeper:

“Oh? This is how you can smuggle a Python binary into a Mac app? I didn’t know Apple allowed that. Very cool.”

2.

It’s been an hour.

*“I’m learning,” *I say inwardly, and congratulate myself for having the wisdom to balance instructions with questions.

“Make this change… now explain this pattern to me.”

It’s a partnership. Progress seems instant, we move faster and faster. I don’t even need to edit, I can provide directions and just review the changes.

“Float this element to the right…”, “When the user presses this, make sure the state updates as follows…”, “Not quite like that, like this…”

Claude can do everything. This project will be finished in no time.

3.

He’s really churning out the code now. Since every change is so small, there’s no need to review them. I’ve stopped asking questions — I have the gist now, and more importantly, so does he.

It’s been a few days (time flies), but I’ve made great progress.

4.

“Wait. Haven’t we been here before?”

I’m definitely not lost (let alone trapped)… but admit there have been issues.

He’s lost the thread a few times, and there have been one or two lapses in judgement. Minor difficulties, nothing serious.

I know exactly what’s needed, of course: tests. Automated tests will solve everything.

Though really, probably best if he writes them. He knows the codebase, after all.

5.

More setbacks. But it’s fine, the app is basically working, and it’s been barely two weeks.

I understand his limits now, and am in control. I’m not frustrated, but will be more rigorous: detailed prompts and firm acceptance criteria.

I even smirk — this is almost like pre-agile software development.

Every change now comes with its own git commit and documentation file.

I’ll definitely read these.

6.

I’m lost, again. When did this start?

It’s fine though, the app is mostly there.

I’ll just dive into the code myself to see what the trouble is.

Yes, it’s as I expected. There are a lot of files… the code is too complicated! It should not have made it so complicated.

I’ll ask for an analysis and refactor. “— please”.

Disable tests? Well I suppose that’s alright… ‘Allow’

7.

I was almost ready to release, but there’s been a snag.

Turns out that major architectural decision was probably wrong.

How frustrating. It must be the third time this has happened — remember the Apple binaries debacle?

I questioned it at the time, but it was so confident and reassuring.

Maybe I’ll switch models again.

Either way, I need to coax it into redoing the whole backend, again.

8.

It’s been a month. I’m in the heart of the labyrinth.

The codebase is an abomination. My sessions alternate between begging and berating. I’ve lost count of refactors. I don’t know if it will ever finish.

I look at the latest regression, and for the hundredth time express bewilderment:

“Why has this broken again? I thought you fixed it? It’s a mess.”

The terminal churrs and SCP-LLM replies:

“You’re absolutely right. We should refactor.”