difficult-clientsVersion 1.0

Screen a client before you sign

Run a vetting script on every call, log red flags, and price the contract around what surfaces before you sign. This AI skill catches bad-fit clients early.

“clients didn't have a clue what they wanted, ignored advice, quibbled over bills”
David Hart, Substack

The problem

You already know the feeling: a call goes well, the gut says proceed, and three months later you're chasing an invoice. A standing pre-signature vetting script turns that feeling into a written record instead: the same questions every call, logged and scored, so the accept, price-up, or decline decision has evidence behind it, not just a good vibe from the room. Flagged answers convert directly into proposal terms: a bigger deposit, a different milestone split, a change-order clause, instead of getting waved off because the call felt fine. A monthly review checks which flags actually predicted trouble and tightens the script over time.

Screen a client before you sign

Key takeaways

  • Ask the same screening questions on every discovery call, not just the ones that feel risky, because the good-feeling call is exactly the one where you skip a step and regret it later.
  • Log the prospect's own words for scope and budget, not your summary of them; the record is only useful if it's what they actually said.
  • Score answers against named patterns: scope vagueness, blame-the-last-vendor, payment-term resistance, no decision-maker in the room, and set a flag-count threshold that triggers a second call instead of a quote.
  • Match each flag to a specific contract term: payment resistance raises the deposit, vague scope gets the change-order clause, a missing decision-maker gets a named-signer requirement before the deposit is invoiced.
  • Never send a proposal off a single call when the flag count is high or an answer was ambiguous; a second call with the same questions asked directly is cheaper than a bad contract.
  • Review closed deals on a monthly or quarterly cadence to see which flags actually predicted a late payment, a scope fight, or a termination, and tighten the script when a pattern slips through twice.
SKILL.md

Frontmatter

name
screen-client-before-signing
description
Runs a standing pre-signature vetting script on every discovery call, logs the answers to a timestamped deal record, and turns what surfaces into priced proposal terms (deposit, milestone billing, a scope-creep clause) before any contract goes out, scripts a decline when the record says no, then runs a pre-written exit path if a flagged pattern shows up anyway. Use when the user is about to quote or propose a new prospect, asks how to spot a bad-fit client early, wants a script for a discovery call, or reports a client relationship that soured after work started. Triggers include "how do I vet a new client", "red flags before I sign this client", "screen this prospect before I quote", "client turned into a nightmare", "should I take this client".

Screen a client before you sign

This skill runs a standing intake ritual on every discovery call so the accept, price-up, or decline decision comes from a written record instead of end-of-call gut feel. Invoke it any time the user is heading into or just finished a discovery call with a new prospect, is about to draft a proposal, asks for red flags to watch for, or reports a client engagement that went bad and wants to know what to change going forward.

The bundle carries everything each phase needs: references/vetting-script.md (the standing questions and what a red-flag answer sounds like), references/intake-record-template.md (the fields to log per deal), references/red-flag-scoring.md (how many flags trigger which gate), references/pricing-levers.md (deposit, milestone billing, and scope-creep clause defaults), references/decline-script.md (the call script and written fallback for the decline gate outcome), references/exit-playbook.md (the termination sequence when a flag materializes anyway), and examples/filled-intake-example.md (one worked record showing the template filled in). Read the referenced file before running the step that names it; do not improvise a question, a clause, or a termination line from memory when a bundle file defines it.

Phase 1: Set up the standing system once

  1. Read references/vetting-script.md with the user and confirm the question set it defines. If the user wants to add or drop a question, edit that file with them; do not silently change the script mid-engagement without their sign-off.
  2. Read references/intake-record-template.md and confirm where the user wants each vetted deal logged (their CRM opportunity record, a shared doc, a plain notes file). Set up that location once so every future discovery call has somewhere to write into.
  3. Read references/pricing-levers.md and get the user's explicit defaults: their standard deposit percentage, whether they use the 25/50/25 milestone split or their own split, and their standard scope-creep buffer or change-order clause wording. Record these defaults in the intake location from step 2 so later phases reuse them instead of asking each time.
  4. Read references/red-flag-scoring.md and confirm the user agrees with its flag-count thresholds (how many flagged answers trigger a second call, adjusted terms, or a decline). Adjust the thresholds with the user if their risk tolerance differs, and save the agreed version.

Phase 2: Run the vetting script on every discovery call

  1. Before drafting any proposal for a new prospect, ask the standing questions from references/vetting-script.md, in the same order, on every call. Do not skip a question because the call is going well; a good-feeling call is exactly the condition this script exists to check against.
  2. Log the prospect's answers into the intake record from references/intake-record-template.md, timestamped and tied to this specific deal. Capture the prospect's own words for scope and pain, not a summary in the seller's own language. Never log an answer the prospect did not actually give.
  3. Score the logged answers against the patterns in references/red-flag-scoring.md. Count how many flags are present (scope vagueness, blame-the-last-vendor pattern, payment-term resistance, missing decision-maker, or any other pattern that file defines).
  4. Apply the second-call rule from references/vetting-script.md: if the flag count from step 7 is at or above the threshold set in Phase 1, or any answer was ambiguous, do not draft a proposal off a single call. Schedule a second call and re-ask the flagged questions directly, watching for whether the prospect's answer changes under a direct follow-up.
  5. After the call (or calls) are done, write the gate decision into the intake record: proceed on standard terms, proceed on adjusted terms, or decline. Write the reasoning in one line tied to the specific flags found, not a general impression. If the decision is decline, read references/decline-script.md and use its call script (or its written fallback) rather than improvising a decline message.

Phase 3: Convert flags into priced proposal terms

  1. For any deal that cleared Phase 2 with one or more flags, apply the levers from references/pricing-levers.md: raise the deposit percentage, structure billing on the milestone split with concrete, client-visible deliverable triggers ("approved homepage design," never "halfway done"), and add the scope-creep buffer or change-order clause. Match the lever to the specific flag: payment-term resistance raises the deposit, scope vagueness gets the scope-creep clause, a missing decision-maker gets a named-signer clause before the deposit is invoiced.
  2. Draft the proposal with these terms filled in. Before sending it anywhere, present the full draft to the user in this turn and wait for an explicit yes. Never send, email, or queue a proposal without that approval, regardless of how routine the deal looks.
  3. On approval, hand the approved proposal text to the user's own send channel (their email client, their proposal tool, their CRM). This skill never sends a message on the user's behalf.
  4. Log the final terms that went out, and the date, in the intake record so the record stays the single source of what was actually proposed.

Phase 4: Review the record on a standing cadence

  1. On a monthly or quarterly cadence (whichever the user sets), or whenever the user asks for a review, pull every intake record logged since the last review. Use examples/filled-intake-example.md as the reference shape so records stay comparable across deals.
  2. Check which flagged patterns from step 7 correlated with an actual problem later (late payment, scope fights, a termination). If the same pattern shows up as a false negative (no flag was raised, but the engagement still went bad) at least twice, propose an edit to references/vetting-script.md or references/red-flag-scoring.md to catch it next time.
  3. Present the proposed edit to the user for approval before changing either reference file. Do not modify the standing script or the scoring thresholds on your own judgment; this is the user's system, and the agent's job is to surface the pattern, not to unilaterally rewrite the rules.
  4. Note explicitly in the review that a documented vetting record makes an engagement auditable by a second reviewer; it is not a proven predictor of the accept or decline decision on its own. Do not claim a specific success rate, lift, or percentage improvement from using this system unless the user has real data of their own that shows it.

Phase 5: When a flagged pattern shows up anyway, run the exit path

  1. If a client the record flagged (or even one that cleared clean) starts showing the pattern in practice, read references/exit-playbook.md and start with its first step: raise the specific problem directly with the client. Most flagged patterns are recoverable with a direct conversation before they require ending the engagement.
  2. If the problem is not resolved after that direct conversation, draft the termination approach from references/exit-playbook.md: end the relationship on a call, not by email, cite the specific documented pattern from the intake record (not a vague "this isn't working"), offer a referral or handoff where one is reasonable, and hold final deliverables until the account is settled.
  3. Present the termination talking points, and any written follow-up (an email confirming the call, a final invoice note), to the user for approval before they are used. A phone call cannot be pre-approved line by line, but the talking points and any accompanying written message go through the same explicit-yes checkpoint as any other send-gated action.
  4. Once the engagement is closed, log the outcome and the final payment status in the intake record, and feed it into the next Phase 4 review so the record keeps improving against what actually happened, not just what was predicted at intake.

Copy-paste checklist: every discovery call

  • All standing questions from references/vetting-script.md asked, in order, this call
  • Answers logged in the prospect's own words, not paraphrased into the seller's language
  • Flag count scored against references/red-flag-scoring.md before any proposal is drafted
  • Second call scheduled if the flag count or an ambiguous answer calls for it
  • Gate decision (proceed / adjust / decline) written into the record with a one-line reason, decline messages drawn from references/decline-script.md

Copy-paste checklist: before any proposal goes out

  • Pricing levers from references/pricing-levers.md matched to the specific flags found, not applied blanket
  • Milestone triggers are concrete and client-visible, not vague progress language
  • Full draft shown to the user and an explicit yes given in this turn
  • Final terms and send date logged in the intake record

Copy-paste checklist: standing review cadence (Phase 4)

  • Every intake record logged since the last review pulled and lined up against examples/filled-intake-example.md for shape
  • Each flagged pattern checked against what actually happened later (on-time payment, late payment, scope fight, termination)
  • Any pattern that missed twice (no flag raised, but the engagement still went bad) written up as a proposed edit
  • Proposed edit to references/vetting-script.md or references/red-flag-scoring.md presented to the user for approval before either file changes
  • No specific success rate, lift, or percentage claimed unless the user has their own measured data to back it

Copy-paste checklist: closing out a flagged engagement

  • Specific problem raised directly with the client before any termination step starts
  • Termination happens on a call, not by email
  • Talking points cite the documented pattern from the intake record
  • Referral or handoff offered where reasonable
  • Final deliverables held until the account is settled
  • Outcome and payment status logged back into the record for the next Phase 4 review

Guardrails: the ways this fails

  • Never invent a client detail, a quote, a payment history, or a fact about the engagement that is not present in the call notes, the thread, or the intake record.
  • Never skip the vetting script because a call felt unusually good; urgency to close and urgency to do good work are exactly the pressures that suppress this signal, which is why the script runs identically every time.
  • Never draft, send, schedule, or queue a proposal, an email, a decline message, or a termination message without an explicit yes from the user in that turn. A drafted message with no reply is not an approval.
  • Never treat the intake record as proof that vetting changes outcomes by a specific amount. Frame it as an auditable record that helps a second reviewer see what was actually said, not as a guaranteed predictor, and never cite a specific success rate that the user has not measured themselves.
  • Never rewrite references/vetting-script.md or references/red-flag-scoring.md on inference alone; a pattern needs at least two confirmed misses before it is proposed as an edit, and the edit itself needs the user's approval before it is saved.
  • Never terminate a client relationship by email when a call is possible, and never hold back the documented pattern from the termination conversation in favor of a vague explanation.
  • Never present the scope-creep clause, the named-signer clause, or the "hold final deliverables until the account is settled" practice as vetted legal advice. Contract enforceability, lien law, and consumer or commercial protections all vary by jurisdiction, so tell the user to verify the exact clause wording, and any deliverable-withholding practice, against their actual contract and local law before relying on it verbatim.
  • Stop the procedure and ask the user directly if the intake record is missing, contradictory, or was never logged for a deal; do not reconstruct a vetting history for a deal that skipped Phase 2.

Install

  1. Download the .skill bundle, or the raw SKILL.md above.
  2. Unzip the bundle into your agent's skills directory. SKILL.md sits at the top level; any reference files sit beside it.
  3. Point your agent at the folder. It reads SKILL.md and follows it.

What's in the bundle

The .skill download contains SKILL.md plus these files, each at its path.

SKILL.mdthe skill on this page
references/vetting-script.md2,875 chars
# Vetting script: the standing questions

Ask these on every discovery call, in this order, before you draft a proposal. Do not skip a question because the call feels good. A good-feeling call is exactly the condition this script checks against.

## The questions

1. **Scope.** "Walk me through exactly what you want built or fixed, start to finish." (Listen for a concrete deliverable list versus a vague wish. "Something like what my competitor has," with no specifics, is a flag.)
2. **Timeline.** "When do you need this live, and why that date?" (A real business reason, a launch, an event, a contract deadline, is fine. "Yesterday," with no reason attached, is a flag.)
3. **Budget.** "What have you budgeted for this, roughly?" (A number, even a range, is fine. "What do you charge?" deflected back at you three times is a flag.)
4. **Decision maker.** "Who signs off on this and cuts the check?" (Get a name. "I'll run it by my partner, my board, my spouse," said after you've already quoted, is the flag, not the mention itself.)
5. **Last vendor.** "Have you worked with someone else on this before? How did that go?" (Listen to how they talk about the last person. One bad story can be true. Three, or contempt with no specifics, is a flag.)
6. **Payment terms.** "My standard terms are a deposit up front and milestone billing. Does that work for you?" (Say your real terms out loud on this call, not after the proposal. Resistance, "can we start and figure out payment later," or "I don't pay deposits on principle," is a flag.)
7. **Success picture.** "What does done and working look like to you, in your own words?" (Vague, shifting, or "I'll know it when I see it," is a flag. It means scope will keep moving.)

## What a flag sounds like

- **Scope vagueness:** describes the outcome, not the deliverable; keeps saying "you're the expert, figure it out."
- **Blame-the-last-vendor:** every past vendor was terrible, incompetent, or a scammer, with no specifics about what actually went wrong.
- **Payment-term resistance:** pushes back on the deposit or milestones more than once, or asks to start work before terms are settled.
- **Missing decision-maker:** the person on the call cannot commit without someone absent, and that someone has not been named or looped in.
- **Ambiguous success picture:** cannot describe "done" in concrete terms even after a second try.

## The second-call rule

If the flag count from `references/red-flag-scoring.md` is at or above the agreed threshold, or any single answer above was ambiguous, do not draft a proposal off this one call. Book a second call and re-ask the flagged questions directly: "Last time we talked about X, tell me more about that." Watch whether the answer changes, sharpens, or gets defensive under a direct follow-up. A sharpened answer clears the flag. A defensive or evasive answer confirms it.
references/intake-record-template.md1,929 chars
# Intake record template

Copy this into the deal log for every new prospect, the first time the vetting script runs on them. One record per deal. Fill in the standing defaults once during setup, then everything below for each new deal.

## Standing defaults (fill in once, reuse for every deal)

- Standard deposit: ____%
- Milestone split: 25/50/25, or your own: ____
- Scope-creep buffer / change-order clause wording: (paste the agreed version from `references/pricing-levers.md`)
- Flag-count threshold for a second call: ____
- Flag-count threshold for auto-decline: ____

## Deal record

- **Prospect / company name:**
- **Date of call 1:**
- **Date of call 2 (if triggered):**
- **Logged by:**

### Answers (prospect's own words, not paraphrased)

| Question | Answer as given |
|---|---|
| Scope | |
| Timeline | |
| Budget | |
| Decision maker (name) | |
| Last vendor experience | |
| Payment terms reaction | |
| Success picture | |

### Scoring

| Flag pattern | Present? (Y/N) | Note |
|---|---|---|
| Scope vagueness | | |
| Blame-the-last-vendor | | |
| Payment-term resistance | | |
| Missing decision-maker | | |
| Ambiguous success picture | | |
| **Total flags** | | |

### Gate decision

- [ ] Proceed, standard terms
- [ ] Proceed, adjusted terms (list below)
- [ ] Second call scheduled
- [ ] Decline

**Reasoning (one line, tied to the specific flags):**

### Adjusted terms applied (if any)

- Deposit raised to: ____% (reason: ____)
- Milestone triggers: ____
- Scope-creep clause added: Y/N (wording used: ____)
- Named-signer clause added: Y/N

### Proposal sent

- **Date sent:**
- **Terms that went out (final):**
- **Approved by user before sending:** Y/N

### Outcome (fill in at the standing review or on close)

- **Payment history:** on time / late / disputed
- **Scope held or crept:**
- **Did the flag pattern predict the outcome?** Y/N
- **If terminated:** date, reason, referral given (Y/N)
references/red-flag-scoring.md2,172 chars
# Red-flag scoring

Score every logged deal against these five patterns. Count how many are present. The count decides the gate.

## The patterns

1. **Scope vagueness.** The prospect cannot name a concrete deliverable after being asked twice. "Something modern," "what my competitor has," "you're the expert," with no list of what "it" actually is.
2. **Blame-the-last-vendor.** Every past vendor is described as terrible with no specific, checkable complaint. Contempt without detail is the tell, not the fact that a past project went badly.
3. **Payment-term resistance.** Pushes back on the deposit or milestone structure more than once, or asks to begin work before terms are agreed in writing.
4. **Missing decision-maker.** The person on the call needs sign-off from someone who was not on the call and has not been named or looped in by the second call.
5. **Ambiguous success picture.** Cannot describe what "done" looks like in concrete, checkable terms, even on a direct follow-up.

## Thresholds (defaults; adjust with the user during setup and record the agreed numbers in the intake record)

- **0 flags:** proceed on standard terms.
- **1 flag:** proceed, but apply the matching lever from `references/pricing-levers.md` to that specific flag.
- **2 flags:** do not draft off one call. Book a second call and re-ask the flagged questions directly before any proposal goes out.
- **3 or more flags, or the same flag confirmed a second time on the follow-up call:** decline, or proceed only on materially adjusted terms the user explicitly signs off on (higher deposit, shorter milestone cycle, named-signer clause, or all three).

## Notes on scoring

- Score what was actually said, not a vibe. If you cannot point to the specific words that triggered a flag, do not log it as a flag.
- A single bad-vendor story with real, specific detail ("they missed three deadlines and never gave a revised timeline") is not automatically a flag. Vague contempt with no detail is.
- These thresholds are the user's system. Do not change them without the user's explicit approval, even if a pattern looks wrong in hindsight; raise it at the next standing review instead.
references/pricing-levers.md3,231 chars
# Pricing levers

Convert flags from the vetting script into priced, written proposal terms. Match the lever to the specific flag that triggered it. Do not apply every lever to every flagged deal; apply the one that addresses the actual risk.

## Standard defaults (confirm with the user, record in the intake template)

- **Deposit:** ____% of total project value, due before work starts.
- **Milestone split:** 25/50/25 (deposit, midpoint, final) is a common default. Some sellers use 50/50 or a straight monthly draw for longer engagements. Use the user's own standard once they've stated it, not this default.
- **Scope-creep buffer:** a fixed number of revision rounds or hours included in the quoted price, with anything past that billed at an agreed hourly or day rate.

## Milestone triggers (write these into the proposal, client-visible and concrete)

Use a deliverable the client can look at and confirm, never a vague fraction of effort.

- Correct: "approved homepage design," "staging site live for client review," "final files delivered and client sign-off received."
- Wrong: "50% complete," "halfway done," "most of the work finished."

## Matching a lever to a flag

| Flag | Lever |
|---|---|
| Payment-term resistance | Raise the deposit percentage above the standard default. Consider requiring the deposit non-refundable once work begins. |
| Scope vagueness | Add the scope-creep clause: a fixed number of revision rounds in the quoted price, everything past that at a stated hourly or day rate, written into the proposal, not left as a verbal understanding. |
| Missing decision-maker | Add a named-signer clause: the proposal names the actual decision-maker as the signer, and the deposit is not invoiced until that person has signed. |
| Blame-the-last-vendor | Add explicit written deliverable definitions and a mutual communication-cadence clause (an agreed check-in schedule), so "this isn't what I meant" has less room to happen. |
| Ambiguous success picture | Do not quote a fixed final price yet. Quote a paid discovery or scoping phase first, with the fixed-price proposal to follow once the deliverable is written down and confirmed by the client in writing. |

## Scope-creep clause, sample wording

> This proposal includes [N] rounds of revisions on each milestone deliverable. Additional revisions, or requests that fall outside the deliverables listed above, will be quoted separately or billed at $[rate]/hour, with written approval from the client before work begins.

Adjust the bracketed values to the user's own rate and revision count; do not invent a number. This sample is a starting point, not a reviewed contract; confirm the actual wording against the user's own contract and local law (see the skill guardrails) before it goes into a signed agreement.

## Named-signer clause, sample wording

> This agreement is executed by [decision-maker name], who confirms authority to approve project scope, payment terms, and sign-off on deliverables. The deposit invoice will be issued upon receipt of this signed agreement.

Same caution applies: this is sample language, not legal advice, and enforceability of a named-signer requirement can vary by jurisdiction and business structure.
references/decline-script.md2,819 chars
# Decline script: when the vetting record says no

Use this when Phase 2 scoring, and a second call if one was triggered, puts the gate decision at decline (`references/red-flag-scoring.md`: 3 or more flags, or the same flag confirmed a second time on the follow-up call). Present this language to the user for approval before it is used, same as any other send-gated language in this skill.

## When to use this

Decline is one of three gate outcomes at step 9, alongside proceed on standard terms and proceed on adjusted terms. It is the right call when the flag count stayed at or above the auto-decline threshold after a second call, or when a single flag is severe enough on its own that no pricing lever fixes it: a decision-maker who never gets named after two calls, or a prospect who will not agree to any deposit in writing at all.

## The call (the default; prefer this over email or text)

A decline does not need a long justification. Keep it to two or three sentences and do not negotiate on the call.

Sample opener:

> "Thanks for walking me through this. After our conversation(s), I don't think I'm the right fit for this project, so I'm going to pass. I want to be upfront rather than string this along."

If the prospect asks why, give one concrete, non-personal reason tied to the actual mismatch, never a vague brush-off and never a personal judgment about the prospect:

> "The scope and timeline you're describing don't line up with how I price and structure a project I'd stand behind. I'd rather say that now than partway through the engagement."

## Written fallback, only when a call genuinely was not possible

A call is still the default. Use written language only when a call attempt genuinely failed (no response to a scheduling request, the relationship was entirely async from the start).

> "Thanks for the time you put into this. After going through the details, I don't think this is a good fit on my end, so I'm going to pass rather than take on something I can't deliver the way I'd want to. Wishing you luck finding the right person for it."

## Referral, only when it is genuinely warranted

Offer a referral only when a specific person or resource actually fits and nothing on the call raised a trust issue (a blame-the-last-vendor pattern with real contempt, or payment-term hostility). A referral is a real recommendation, not a reflexive politeness; do not offer one you would not actually stand behind.

## Log it

Write the gate decision, the flags that drove it, and which decline language was used (call or written) into the intake record at step 9, same as any other gate outcome. This keeps declined deals visible at the next Phase 4 review, so a pattern of repeated declines on the same flag can be checked against whether the threshold is still calibrated correctly.
references/exit-playbook.md3,429 chars
# Exit playbook: when a flagged pattern shows up anyway

Use this when a client, flagged or not at intake, starts showing one of the red-flag patterns in practice during the engagement. Most of these are recoverable with a direct conversation. Termination is the last step, not the first.

## Step 1: Raise it directly

Have a direct conversation with the client before assuming the relationship is over. Name the specific pattern you are seeing, tied to something concrete, not a general feeling.

Sample opener:

> "I want to flag something before it becomes a bigger issue. We agreed the milestone deliverable was [X], and I'm seeing requests that go past that scope. Can we talk through what you actually need, and get it written into the plan so we're both working from the same page?"

Give the client a real chance to respond and adjust. Log the conversation and the outcome in the intake record. Most flagged patterns end here.

## Step 2: If it is not resolved, prepare the termination approach

If the direct conversation does not change the pattern, prepare to end the engagement. Draft the following before the call, and get the user's explicit approval on all of it before it is used:

1. **The call, not an email.** End the relationship on a call. A termination-by-email reads as cowardly and invites a worse written dispute later.
2. **Cite the documented pattern.** Reference the specific pattern from the intake record ("we discussed the scope issue on [date], and it's continued past what we agreed"), not a vague "this isn't working."
3. **Offer a referral or handoff where reasonable.** If the work is salvageable by someone else and the relationship allows it, offer a referral. This is not required when the client has been abusive or is disputing payment in bad faith.
4. **Hold final deliverables until the account is settled.** Do not hand over final files, source assets, or credentials until outstanding payment is resolved, consistent with the contract terms. Withholding deliverables carries its own legal footing that varies by jurisdiction (lien rights, contract language, consumer-protection rules); confirm this practice against the user's actual contract and local law before advising it as a blanket rule (see the skill guardrails).

## Step 3: Written follow-up

After the call, send a short written follow-up confirming what was said: the reason for ending the engagement, the final invoice or settlement amount, and what happens to any outstanding deliverables. Present this written message to the user for approval before it is sent, same as the talking points; a call cannot be pre-approved line by line, but everything written can be and must be.

Sample written follow-up:

> "Following up on our call today. As discussed, we're ending our engagement effective [date], due to [specific pattern, e.g. repeated scope changes past what was agreed in the signed proposal]. Final invoice for [amount] is attached, due [date]. [If applicable: happy to recommend someone else for the remaining work.] Files will be released upon receipt of final payment, per our agreement."

## Step 4: Close the loop

Once the engagement is closed, log the outcome and final payment status in the intake record. Feed it into the next standing review (`references/red-flag-scoring.md` and the review cadence) so the scoring keeps improving against what actually happened, not just what was predicted at intake.
examples/filled-intake-example.md4,070 chars
# Filled intake example

One worked record, shown as a reference shape for what a completed intake record looks like. Names and numbers below are invented for illustration; do not treat this as a real client.

## Standing defaults (this seller's own, agreed once during setup)

- Standard deposit: 30%
- Milestone split: 25/50/25
- Scope-creep buffer: 2 revision rounds per milestone, additional at $95/hour
- Flag-count threshold for a second call: 2
- Flag-count threshold for auto-decline: 3

## Deal record

- **Prospect / company name:** Riverside Dental Group (example)
- **Date of call 1:** 2026-08-04
- **Date of call 2:** 2026-08-11
- **Logged by:** J. Alvarez

### Answers (prospect's own words)

| Question | Answer as given |
|---|---|
| Scope | "We need a new website, something modern, you know what dental sites look like these days." |
| Timeline | "Before our 20th anniversary event, October 15." |
| Budget | "We haven't really set a number, what do you usually charge?" |
| Decision maker | "I handle this, my partner Dr. Kim doesn't really get involved in this stuff." |
| Last vendor experience | "Our last web person just disappeared on us halfway through, never finished, total nightmare." |
| Payment terms reaction | "A deposit up front? We usually just pay when it's done." |
| Success picture | "Something that looks professional and gets us more new patients." |

### Scoring

| Flag pattern | Present? | Note |
|---|---|---|
| Scope vagueness | Y | "Modern," no deliverable list; deflected "what does modern mean to you" twice |
| Blame-the-last-vendor | N | Specific complaint (vendor disappeared mid-project), not vague contempt |
| Payment-term resistance | Y | Pushed back on deposit, asked to pay on completion instead |
| Missing decision-maker | Y | Dr. Kim is a named partner but explicitly not looped in; deposit not yet approved by an actual signer |
| Ambiguous success picture | Y | "Gets us more new patients" is an outcome, not a checkable deliverable |
| **Total flags** | 4 | |

### Gate decision

- [x] Second call scheduled (then, after call 2, proceed on adjusted terms)

**Reasoning:** Flag count of 4 is above the auto-decline threshold of 3, but the missing-decision-maker and payment-resistance flags both softened on the direct follow-up call: the client agreed to loop in Dr. Kim as signer and accepted a reduced deposit. Scope vagueness and ambiguous success picture did not resolve, so proceeding on adjusted terms with a discovery-phase-first structure rather than a fixed final quote.

### Adjusted terms applied

- Deposit raised to: not raised; reduced from the standard 30% to 20% as a negotiated middle ground, tied to the discovery-phase structure below rather than a full fixed quote
- Milestone triggers: paid discovery/scoping phase first (deliverable: written sitemap and page-by-page content list, client sign-off required), fixed-price build quote to follow
- Scope-creep clause added: Y, wording from `references/pricing-levers.md`, 2 revision rounds per milestone
- Named-signer clause added: Y, Dr. Kim named as co-signer on the discovery-phase agreement

### Proposal sent

- **Date sent:** 2026-08-13
- **Terms that went out:** Paid discovery phase, $1,200, 20% of that due up front, deliverable equals a written sitemap and content list with client sign-off; full build quote to follow discovery.
- **Approved by user before sending:** Y

### Outcome

- **Payment history:** on time
- **Scope held or crept:** held; the discovery phase defined the deliverable concretely enough that the build quote scope did not shift
- **Did the flag pattern predict the outcome?** Partially. The two flags that softened on the follow-up call (payment resistance, missing decision-maker) did not cause problems later. The two that did not soften (scope vagueness, ambiguous success picture) were the reason the discovery-phase structure was used instead of a straight fixed quote, and that structure is what kept scope from creeping.
- **If terminated:** not applicable; engagement is ongoing as of this record

Sources

Merged from the top existing skills on the topic, with credit to every input.

Frequently asked questions

How many red flags is too many before I decline a client?

Three or more, or the same flag confirmed twice after a direct follow-up call, is the standard auto-decline threshold in this system. Two flags means book a second call before you draft anything. One flag just means price around it. You can tighten or loosen these numbers to match your own risk tolerance, but write the number down once so you're not re-deciding it under pressure on every call.

What if a prospect pushes back on a deposit?

Say your real terms out loud on the discovery call, not after you've already sent a proposal. Pushback once is normal. Pushback more than once, or a request to start work before terms are settled, is the payment-term-resistance flag, and the fix is to raise the deposit percentage, not to drop it to close the deal.

Is the scope-creep clause or named-signer clause in this skill actual legal advice?

No. The sample wording is a starting point, not a contract reviewed for your jurisdiction. Contract enforceability, lien law, and what you're allowed to do around holding deliverables until payment all vary by state and country, so get the exact clause wording, and any practice of withholding final files, checked against your own contract and local law before you rely on it word for word.

I already signed a client and the red flags are showing up now. What do I do?

Vetting at intake and handling a problem mid-engagement are two different moves. Raise the specific pattern directly with the client first; most of these are recoverable with one honest conversation. If it doesn't resolve, that's when the termination sequence, not the decline script, applies: ending the relationship on a call and citing the documented pattern instead of a vague complaint.