Jurij Tokarski

Jurij Tokarski

Q&A7 minUpdated:

What Should I Send a Developer First?

A cleaning business lists login, calendar and payments and asks for quotes. Send the problem instead: who has it, what it costs today, what done looks like.

I want someone to build a booking app for my cleaning business. I've listed the features: login, a calendar, payments, notifications. Is that enough to ask for quotes, or what else should I send?

Send the problem, not the features. A developer needs to know who has the problem, what it costs you today and what done looks like.

The feature list comes later. It comes from the developer, and it comes ranked: what to build first, what to buy and what to leave out.

Your list still has a use. It shows what you picture. But a quote built on it prices your guess at a solution, and the problem stays unnamed.

A Feature List Prices the Wrong Thing

Every line on the list gets a price, and none of them gets a rank. So the solution is picked before anyone has asked what the problem is.

In Find the Core I call a list like this a backlog with no spine. It names what the app has, not why it exists.

Half of it is commodity. Login and notifications have been solved a hundred times. They get bought or deferred, and they never come first.

The prices are shaky, too. Ask how long login takes and you get a number that won't hold a password reset lost to spam. Appetite, Not Estimates is about that gap.

So three quotes on the same list compare three guesses. None of them says which feature matters to the business, because the list never said what the business needs.

The cost shows up later. Another booking app owner got a build in six days, and the next features called for a rebuild. The scope had never been pinned.

What a developer can price is the business behind the list. That fits on one page.

One Page About the Business

The page names the problem, who has it, what it costs today, what done looks like and the one constraint that matters.

A bad brief: "Build me a mobile app with a login screen, dashboard, notifications, and payment integration. Timeline: 3 months. Budget: TBD."

A good brief: "Salon owners waste 30 minutes daily on appointment management. We want to save them time and charge $50/month. We have 6 salon owners willing to test it. Budget: $6K."

The first one lists screens. The second covers five things:

  • Who you serve: specific people, not "users".
  • The problem, and the evidence it exists.
  • The value: what it saves them, and what they'll pay.
  • The real constraints: a real deadline and a realistic budget.
  • Openness: the outcome you want, with room for the developer to propose the shape.

Your page has the same five slots, and only you can fill them.

Who books today, and how? What does that cost? What does a good week look like once the app runs?

The budget belongs on the page, too. It tells the developer how much risk you're willing to take.

A date belongs there only if it's real. A real deadline is one after which the work has no value, and most deadlines are wishes.

That page is short on purpose. The next question is whether it should be longer.

A PRD Can Wait

For one developer and a first build, the page is enough.

A product requirements document (PRD) spells out what the software does, who it's for and what done means. The brief says why to build. The PRD says what, exactly.

You don't need one to hire a developer. Shaping scope is the craft between strategy and execution, and a good developer does it with you. A PRD written alone fixes the features before anyone has questioned the problem: the feature list again, only longer.

Often the better next step is a small build: a prototype before the MVP. A small real thing tests more than a long document does.

A PRD is a plan, and a plan goes stale the day after it's written. Writing a PRD is still worth it: put in as much data and thinking as you have.

Don't treat it as the task list, though. It changes on day one. Read it as a handoff document, and ideally keep it alive: the shape of what's done and what's planned.

One builder never asks questions at all: a coding agent.

Agents Need the Page, Plus Rules

An agent like Cursor or Claude Code gets the same page. It also needs what it can't guess: the stack, the files it may touch and how to check its work.

It does what the text says. I learned that in three debugging sessions, where the model followed my prompts exactly as written.

So the document has to do the arguing, and for an agent it grows into four parts:

  • The core first: the one thing the software must do, and the time you'll give it.
  • Stories with criteria: each feature as a user story with two or three testable acceptance criteria.
  • What stays out: each cut named, with the simpler version that ships instead, such as email before real-time.
  • Stable headings: Markdown with fixed section heads, so one story pastes into a session with its criteria attached.

The difference shows in a single line. "User can manage their profile" is a wish, and it leaves the agent guessing. A story with criteria is something it can test.

Name the traps as well. Real-time updates, roles and permissions, search with filters, file uploads and multi-tenancy look small in a list. An agent builds them as asked.

On your list, notifications is the line to shape first: an email may be all the first version needs.

Project Scope, my free PRD generator, drafts that document from a short description and refuses stories without acceptance criteria. Read what it drafts before an agent builds from it.

Whoever builds it, a person or an agent, the first thing they get is the same page.

Most Listed Features Go Unused

A feature list has a cost no quote shows. Pendo's 2019 Feature Adoption Report found that 80% of features in the average software product are rarely or never used.

A quote that prices every line pays for those too. A page that names the problem first lets most of them wait until a user asks for one.

How I Answer a Brief

With me, that page goes into the project form, which takes about a minute. My pages for small businesses ask for one more line: the job that eats your week.

Before I reply, I read what's public about the business: the site, the product, its history. My questions are then the ones research can't answer.

I reply the next working day. If it fits, the reply carries questions, a first plan and a call invite.

A budget smaller than the ask isn't a no. My first answer is a smaller version that fits.

A fixed price for a full spec is the one thing my reply won't carry. I work by the week: a one-week job is priced up front, and a longer one comes back as an estimate in weeks.

There's no PRD phase either. On the retainer, the task board becomes the roadmap.

Each task fits in a line: add sign-in, take payments, automate a weekly report. Your four features would land there as tasks, in the order the page sets.

Work starts the working day after you subscribe, with setup. I prepare the development environment and access, and read any code that already exists. Then the building starts.

How I Brief My Own Agents

My agents get the page plus the rules. Each workspace I set up for them has a clear structure and skills for the jobs that repeat. A knowledge base says how I want the work done.

Tests and review agents then check what they built.

In my own work, the order also runs the other way. Agents draft the plan, with a recommended default for every decision, and the plan is my first call. On one feature my whole answer was three words: "execute the plan."

What the Owner Should Send Now

Send the one page. The reply says what to build first and what to leave out, and then the first week starts.

For your cleaning business, that first week builds what the page put first. The list was your answer. The page is the question a developer can price.

Got thoughts on this? Reply by email.

Jurij Tokarski

Jurij Tokarski

I run a solo business and produce software. Usually I'm shipping for clients or building for myself. Sometimes I pause to write about it.

x.comlinkedin.comjurij@varstatt.comRSS