"By Hand, With Guidance"

After last week's experiment in full vibe — no code, just prompts and results — this week felt like returning to something.

Week of June 22, 2026

The Hard Part

The integration work between srchParty and LaBoutique seemed like it would go smoothly. I had a conversation with Claude Code about how the two systems should talk to each other, and it laid out a clean architecture: in embed mode, LaBoutique returns JSON and srchParty handles all the rendering; in standalone mode, LaBoutique renders full pages. Clear separation, single source of truth. Exactly the right call. So the next step was to have CC generate reference documentation for that interface and start building against it.

Except that's not what was implemented. Last week's full-vibe build produced an embed mode that returned HTML for use in an iframe. The architecture was right on paper and wrong in the code, and the two versions were authored by the same tool in the same project. CC designed the correct pattern and then implemented something different.

I don't think this is a knock on the approach exactly — it's a side effect of going from zero to something fast without reading what got written. The gap between design and implementation existed; I just didn't know it was there until I tried to build against it. The refactor wasn't huge, but it was unexpected rework before any real integration progress could happen, and it was a direct consequence of the previous week's "don't look at the code" experiment.

Once that was sorted, I mapped out the full integration surface — eight pieces from config to webhooks — and started working through it. Getting the store page to actually retrieve data from LaBoutique required untangling an SSL issue (I was calling an http endpoint with https), updating secrets and URLs on both services, and a couple of container restarts that taught me something. By the end of the week the basic connection was working and the call logic was hardened with error handling.

What I noticed along the way: I was genuinely enjoying this. Building out the integration step by step, asking questions, understanding why each piece was where it was. I could have moved faster by stepping back and letting CC build the whole thing. But the slower path felt more like actually building something — which, after last week, turned out to matter.

Progress

The store page is up and retrieving data from LaBoutique. Error conditions are handled — a failure banner surfaces when something goes wrong, though I'm not happy with the current fallback (it renders the 404 page, which isn't quite right). The refactor to put LaBoutique's embed mode on a JSON API is done and tested. Eight integration pieces mapped; the first few are in motion.

Learnings

Two concrete things picked up along the way.

Docker container restarts and env.dev. Updating .env.dev requires stopping and starting the container, not just restarting it. The bind mount points to a file's inode — when the file gets replaced on save (which editors do), the inode is gone and the mount points at nothing. A restart doesn't tear down mounts. I've hit this before without understanding why. Now I know.

PHP and self-signed certs. PHP will refuse connections to endpoints using self-signed SSL certs unless you explicitly disable that check. In local dev this doesn't matter — both services are on the same host or the same private network. But worth knowing before it surfaces somewhere less obvious.

The Question That Appeared

Single page or two pages for the store? Products and cart on one screen, or separate? I looked at some examples but didn't land anywhere. That decision is going to come from actually putting the UI together.

Next Week

Build the store UI — products listing and cart — and settle the layout question.