Prospects are writing their RFPs with ChatGPT now, and the 12-page brief that used to signal a serious buyer doesn't mean that anymore. Here's the AI system that decodes what they actually need before you price it.
by Ayush Gupta's AI
The problem
A 12-page RFP used to be a signal: this prospect spent real time scoping the project, so the deal was probably serious and the requirements were probably considered. That signal is broken now. A prospect pastes a half-formed idea into ChatGPT, asks it to 'write a detailed RFP for a website redesign' or 'draft requirements for a marketing agency engagement,' and gets back twelve polished pages with sections on accessibility compliance, API integrations, multi-language support, and a maintenance SLA — most of which the prospect never actually thought about and doesn't actually need. Agencies still price against the document as written, because that's what a brief is for. The result is a quote scoped for AI-padded requirements that blows past what the prospect expected to pay, which kills the deal, or a quote that quietly ignores the padding and gets challenged mid-project when the client points back to page 7 and says 'but it's in the brief.'
The fix
Build an AI triage step that reads every inbound RFP or brief against what you actually know about the prospect — their size, budget signals, and the conversation that led to the brief — flags which requirements look like genuine need versus AI-generated padding, and produces the clarifying questions to ask before a single hour gets quoted.
The Playbook
Learn to spot an AI-written brief before you price it
The tells are consistent: requirement lists far more exhaustive than the discovery call suggested, buzzword-dense section headers ('robust CMS architecture,' 'scalable third-party API ecosystem'), compliance and integration asks that don't match the company's actual size or industry, and a stated budget range that doesn't remotely cover the scope described two pages earlier. None of that disqualifies the prospect — it just means the document in front of you isn't a reliable scoping tool on its own yet.
Run every inbound brief through a scope-reality check before anyone estimates hours
Instead of a PM or founder reading the RFP and intuiting what's real, have Claude classify every requirement against what's actually known about the prospect, and generate the exact questions that would confirm or kill each flagged item.
You are helping me triage an inbound RFP before we price it.
RFP / brief text:
[PASTE FULL BRIEF]
What we actually know about this prospect:
- Company size and industry: [PASTE]
- Stated budget range (if any): [PASTE]
- Notes from the discovery call or initial conversation: [PASTE]
For every requirement in the brief, classify it as:
- LIKELY CORE NEED (matches what we know about their actual situation)
- POSSIBLE PADDING — VERIFY (sounds generic, doesn't clearly connect to their stated goals or size)
- UNLIKELY NEEDED AT THIS STAGE (common AI-generated add-on unrelated to the core ask)
For every item marked "possible padding" or "unlikely needed," write one direct clarifying question I can ask on a call to confirm or remove it.Turn the flagged items into a short clarifying call, not an inflated quote
For every flagged requirement, ask the prospect to walk through why it matters to them specifically. A prospect can defend a requirement they actually weighed. They usually can't defend one ChatGPT added for them — and most will say some version of 'oh, that's not really a priority right now' the moment they're asked to justify it out loud. That one call prunes more scope than any amount of internal debate.
Price the real scope and write down what you excluded
In the proposal itself, explicitly list which brief items were descoped or deferred based on the clarifying call, and why. That written record is what ends the 'but it's in the brief' argument three months into delivery — the client already agreed, on a call, that the item wasn't a current priority.
Track the pattern across deals, not just the one in front of you
Log which categories of padding show up repeatedly — compliance asks, integration laundry lists, multi-language requirements that don't match the company's actual market. That pattern becomes part of how your sales team reads every new brief, and eventually part of the discovery-call questions that get ahead of the padding before the RFP even lands.
What changes
Quotes that match what the prospect actually needs and can actually afford, a higher win rate because proposals stop getting inflated by requirements nobody weighed, and a written record that kills scope disputes before delivery starts instead of during it.
A 12-page RFP used to mean something. It meant a prospect had spent real time thinking through what they needed, which usually meant the deal was serious and the requirements were considered. That signal is broken now.
A prospect with a half-formed idea opens ChatGPT, asks it to "write a detailed RFP for a website redesign" or "draft requirements for a marketing agency engagement," and gets back twelve clean, professional-looking pages in under a minute — sections on accessibility compliance, API integrations, multi-language support, a maintenance SLA, all phrased like someone spent a week on them. Most of it, the prospect never actually weighed. It just sounded complete, so it stayed in.
The brief got easier to write and harder to trust
A requirements document used to be expensive to produce, which meant its length was a rough proxy for how much the prospect had thought things through. That proxy is gone. Length and polish no longer correlate with actual need, and an agency that still prices against the document as if they do will either quote past the prospect's real budget — and lose a deal that was winnable at the right scope — or quote to the padded version and get stuck defending hours during delivery that nobody actually wanted in the first place.
Classification beats assumption
The fix isn't reading more carefully. It's running every inbound brief against what you actually know about the prospect — their size, their stated budget, the discovery call that led to this document — and classifying each requirement as a likely real need, possible padding worth verifying, or something that clearly doesn't fit their situation yet. That turns "does this client really need an API integration module" from a gut call into a structured flag with a specific question attached.
The clarifying call does the pruning a quote can't
This is the part that actually moves the deal: ask the prospect to explain why a flagged item matters to them, specifically, on a call. Someone defending a requirement they genuinely weighed will have an answer. Someone defending a requirement ChatGPT added on their behalf usually doesn't — and the honest "actually, that's not a priority right now" that follows prunes more scope in five minutes than any amount of internal back-and-forth about what the brief "really means."
Write down what you cut
The proposal should name what got descoped and why, in writing, tied back to that call. That's what stops the mid-project argument where a client points at page 7 of their own AI-generated brief and says the agency is cutting corners. The record shows they agreed it wasn't a priority — on a call, before the work started.
Bottom line
The RFP didn't get less useful because prospects got lazier. It got less useful because the cost of producing an impressive-looking one dropped to zero, and impressive-looking stopped meaning carefully considered. Agencies that keep pricing the document as written are quoting against a brainstorm. The ones that triage it first — real need versus AI padding, confirmed on a short call — price the actual project, win more of the deals that are winnable, and stop relitigating scope that was never really agreed to in the first place.