Every broken project has one root cause. This session names it — then fixes it.
Pre-work · What came in02 / 11
The homework had a pattern.
Decisions made in isolation. Delivered as surprises.
Gordon — Designer / PM
Holds the vision. Owns the client. Sets the brief.
No scope. Client asked for more. No boundary existed.
Informal dev check-ins — nothing written, nothing confirmed.
Presenting work he couldn't fully sell or explain.
Spacing felt off. No grid. No system to point to.
Jeremy — Developer
Owns the build. Makes technical calls. Executes the station.
Built custom Liquid from scratch — tools unexplored.
Mid-build changes caused regressions. Old code forgotten.
Store transfer wiped every admin config. No checklist.
No Shopify SOP. Answering client questions on instinct.
The thesis03 / 11
Every issue is the same issue.
A decision made without the other person knowing.
The store transfer. The invisible scope. The mid-build change. The Safari bug found at launch.
None of these are isolated. They share one root: no written loop. No checkpoint. No one told.
Case study 0104 / 11
The store transfer.
Should have happened: confirm the account exists. Export the config. Tell Gordon in writing before touching anything.
Jeremy transferred the Arkives store. No account existed on the other side. Every config — payments, shipping, navigation — wiped. Gordon found out after.
A technical decision. No written loop. Nobody told.
Case study 0205 / 11
The invisible scope.
Should have happened: scope written and signed before design was ever shown to the client.
Gordon presented without a scope. No boundary existed. Client asked for changes. Nobody was wrong — the container didn't exist.
A design decision presented without a written container.
Roles06 / 11
Two stations. One kitchen.
Gordon — Executive Chef
Writes the brief. Holds the vision. Owns the client.
BriefClientVision24h review
Not your station: CSS debug · Jeremy's technical calls
When Gordon crosses into Jeremy's station, the kitchen loses its order. Decisions get made twice — or not at all.
Handoff
↕
Written
Jeremy — Craft Director
Owns the build. Flags early. Delivers with proof.
TechnicalQAShopify SOP30-min flag
Not your station: design decisions · absorbing scope changes
When Jeremy absorbs a scope change without flagging it, it becomes invisible debt. It surfaces later — always at the worst time.
Each station is complete. The pass-through is the only place work crosses. That crossing must be written.
Handoff protocol07 / 11
Before anything moves, it's written.
Design → Dev
Gordon hands off
Figma link with annotations on every interaction
Written spec — gaps, animations, breakpoints named
"Ready for Dev" tag = green light to build
No tag → not ready. Full stop.
Without the tag, Jeremy can't tell if the design is final or still moving. Every build on a moving design creates debt.
Dev → Review
Jeremy hands off
Staging link with password
QA checklist — Chrome + Safari both confirmed
"Ready for Review" tag starts Gordon's 24h window
No checklist → not ready. Full stop.
A staging link without a QA checklist is an invitation to find problems at launch. The checklist is the work, not the link.
No verbal handoffs. No assumed readiness. If it's not written, it didn't happen.
Communication rules08 / 11
Flag early. Never absorb.
Blocked 30+ min
Open a card. Not a DM.
Create a Trello card in the active gate column. Tag it Blocked. Gordon responds same day.
A DM disappears. A card stays. The card is the record.
Scope change
Gordon writes it first.
Changed your mind? Write it as a Trello card before the call. Say it after.
Live changes are invisible. Written changes are real.
Any decision → confirmed in writing. Both people confirm they saw it. If it's not written, it didn't happen.
The system09 / 11
Four gates. Nothing skips.
Gate 01
Kickoff
Scope written + signed
Roles confirmed
Dev store ≠ client store
Timeline agreed
0 / 4 done
Skip this: the project starts without a container. Everything that follows is guesswork.
The only gate that protects everything after it. Nothing proceeds without scope.
Gate 02
Design handoff
Figma annotated
Spec written
Tools explored first
"Ready for Dev" tagged
0 / 4 done
Skip this: Jeremy builds against a moving target. Regressions are inevitable.
A spec is not a Figma file. It's everything the file can't say.
Gate 03
Dev handoff
Chrome + Safari QA
Transfer checklist done
Staging signed off
"Ready for Review" tagged
0 / 4 done
Skip this: launch day becomes discovery day. The client finds what you didn't.
The store transfer that wiped Arkives? Gate 03 exists because of that moment.
Gate 04
Close out
Shopify SOP updated
Scope template refined
Debrief card logged
Both sign off
0 / 4 done
Skip this: the next project starts with the same gaps. Nothing compounds.
The debrief is how today's mistakes become tomorrow's SOP.
Click each item to mark it done. Progress saves automatically.
Live exercise · Open Trello now10 / 11
Now open Trello.
Gate 01 — Arkives · Fill this in together, right now
Gordon's cards
Gordon
Write the scope card
What's in. What's out. What costs extra.
Done means: a client could read this card and know exactly what they're getting. If it's vague, it's not done.
Gordon
Set the review window
A date. Not "soon." Not "this week."
A review window without a date is a promise without a deadline. Deadlines make work real.
Both
Agree the timeline
Say it out loud. Write it in the card. Both confirm.
Agreed verbally and written are two different things. Only one of them is a record.
Jeremy's cards
Jeremy
Confirm dev environment
Dev store ≠ client store. Write it.
This is the Arkives lesson. One line in a card prevents the next store transfer from wiping everything.
Jeremy
Log the open bugs
Safari footer. Metafields. Filters. One card each. Owner + ETA.
An unlogged bug is invisible debt. Log it now and it has an owner. Leave it and it has a surprise.
Jeremy
Start the Shopify SOP
One thing you'd do differently. First line only. Now.
The SOP starts as one sentence. Every project adds one more. That's how expertise compounds.
Gate 01 is not closed until every card has a written entry and both of you have confirmed it.
SQUAT_SYSTEM_V2 · Gordon + Jeremy · 202611 / 11
The system is the relationship.
Good collaboration between a designer and a developer is a rare polished gem.
Write your own commitment line. Say it out loud. Then it's real.