Scope Creep: the agent that turns "make it pop" into something you can build

Every engineer has received the ticket. "Make it pop." "Add AI." "Users want more flexibility." Three words, zero clarity, and a sprint about to go sideways. I built an agent that takes those fuzzy requests and turns them into a spec a team can actually build. It's called Scope Creep, and it's the teammate I always wished was in the planning meeting.

What Scope Creep does, and who it's for
You paste a vague feature request. Scope Creep hands back four things, every time:

Acceptance Criteria — concrete, testable statements, in Given/When/Then where it helps.
Edge Cases — the failure modes and boundaries the team will hit.
Questions for the Stakeholder — the sharp clarifying questions to ask before writing code.
The question you're not asking — one punchy, slightly provocative question that surfaces the single thing everyone forgot.
It's for developers and PMs drowning in fuzzy tickets, the people who lose hours to ambiguity that a few good questions would have killed on day one.

How I built it
Scope Creep is a real tool-using agent built on the Strands Agents SDK, AWS's open-source agent framework, with Amazon Bedrock as the model provider (Anthropic Claude Sonnet via the Bedrock Converse API). Strands runs the agent loop: the model reasons, decides whether to call a tool, runs it, and loops until it has an answer.

To make it a genuine agent rather than a single prompt, I gave it a custom tool with the Strands @tool decorator: scope_risk_scorer. It scores how ambiguous and risky a request is (vague-word density, request length) and returns a risk level plus the signals behind it. The agent calls this mid-reasoning to decide how hard to push back, so a one-line "make it pop" gets treated very differently from a detailed request.

The AWS services and tools:

AWS Lambda (Python 3.12) — hosts the Strands agent. Comfortably inside the Free Tier.
Amazon API Gateway (HTTP API) — the public HTTPS entry point that proxies to the Lambda.
Amazon S3 — static website hosting for the chat UI.
Amazon Bedrock — the foundation model behind the Strands agent.
Strands Agents SDK — the agent framework (agent loop + tools).
I split it cleanly: backend logic in Lambda, frontend in S3. The S3 page calls the API Gateway endpoint, and the Lambda returns CORS headers so the cross-origin call just works.

The challenges I actually hit. First, an agent that returns free-form prose is impossible to render or trust, so I treated the output format as a contract: the system prompt pins exactly four headings in a fixed order, backed by a small test suite that asserts the structure holds with the signature question always last. Second, my original plan used a public Lambda Function URL, but the target AWS account's organization policy blocks unauthenticated Function URLs (every request returned 403). Rather than fight a guardrail I couldn't change, I pivoted to API Gateway in front of the Lambda, which is the standard, policy-friendly pattern. Third, packaging Strands for Lambda meant building Linux cp312 wheels and trimming the bundle, I trimmed one dependency too far (watchdog, which Strands imports at load time) and caught it with a quick diagnostic route before shipping clean.

The experience: the one delightful detail
The thing I obsessed over: Scope Creep always ends with "The question you're not asking."

It would have been easy to stop at acceptance criteria. But the magic of a great senior teammate isn't the checklist, it's the one question that makes the whole room go quiet. So I gave the agent a signature move. Ask it to "add AI" and it won't just list criteria; it closes with something like "Are we adding AI because users asked for it, or because the roadmap slide said so?" In the UI, that closer gets its own highlighted card with a gold accent bar, so your eye lands on it last. It reframes the response from "here's your spec" to "here's the thing you should go think about."

How I know it worked: I fed it a batch of real-world vague tickets. On every one, the closing question pointed at a genuine gap, an unstated user, a missing success metric, a hidden assumption about scale. The structured sections make Scope Creep useful; the final question is what makes people actually enjoy using it. It turns a boring translation task into a small "oh, huh" moment every time.

Proof it works
Live agent: http://scope-creep-site-273354655941.s3-website-us-east-1.amazonaws.com

Try it with the worst ticket you've ever received. Type "make it pop" and watch a vague wish become a buildable plan, with one last question that'll stick with you into standup.

Built on the Strands Agents SDK with Amazon Bedrock, deployed as an AWS Lambda function behind Amazon API Gateway, with the chat UI hosted on Amazon S3.

#agents #agent