Partnership

Methodology and relationship can't be separated. How the work happens shapes how the engagement works, and vice versa. Get one wrong and the other falls apart.

Full Visibility

The client sees everything. The task board, the documentation, the repository, the work-in-progress commits. Not a curated summary — the whole thing. After every session there's an update: what got done, what's next, what questions are open.

This demands trust. Trust that the client won't second-guess every micro-decision. But it also creates trust. Nothing is hidden. There are no surprises. Problems surface early, not at delivery.

The best clients disappear for weeks while the developer works, then return with feedback and fresh ideas. That pattern only works when visibility is complete.

Weekly Accountability

Short billing cycles create a tight feedback loop. Good work and the relationship continues. Bad work and the client leaves. There's nowhere to hide.

No long-term contracts to absorb mediocre output. Both sides carry mutual risk — the client risks a short-term payment, the developer risks immediate cancellation. That tension keeps everyone honest.

Priorities Over Scope

Fixed scope creates scope creep. That's the paradox. Remove the scope and there's nothing to creep. Instead, there's a priority queue. The client wants a new feature? Great — where does it sit in the queue?

The WIP limit enforces this. Adding something means stopping something else. That forces real decisions about what actually matters right now.

Async by Default

Written updates are the default. Task comments capture decisions. Slack handles quick questions. The exception is strategic inflection points — architecture changes, major pivots — where a conversation is worth the cost.

Eliminating unnecessary meetings is the single biggest productivity gain available. Most discussions don't need to be synchronous.

Client-Controlled Exit

Easy cancellation isn't a bug — it's a feature. No service provider will ever tell a client to stop paying. The incentive always points toward continuation. Here it's flipped: the client controls the exit. The client decides when the value justifies the cost. That's an honest tension, and it's acknowledged from day one.

Hard Conversations? Fix the Process

Most advice about hard conversations assumes an adversarial relationship. The client wants X, the developer thinks X is wrong, now someone needs a script.

Here's a different take: if a playbook for hard conversations is needed, the process is broken.

Software development is a business cost and the client decides. The developer can consult. The developer can recommend. The developer can flag risks and present alternatives. But the final decision is the client's. They pay, they choose. This isn't passive — it's honest.

When transparency is real, the client sees everything. When weekly accountability is real, there are four exit points every month. When priorities replace scope, the conversation is always "what's most important next?" not "where's everything I was promised?"

In this environment, blow-ups don't happen. Disagreements get resolved in async messages and discovery calls, not in dramatic confrontations. The clients who generate hard conversations are the ones the other principles should have filtered out — saying no at the start, week zero as a mutual audition, easy exit when fit isn't right.

Hard conversations are a symptom, not a condition. Fix the process and the symptom disappears.

What's Ahead

Seven principles shape how the partnership works — from onboarding and pricing that set the right expectations, through full transparency as the foundation, the accountability mechanism and how work gets managed, to the communication model and the freedom to walk away.