Aditya Dutt Pandey

How we work · 2026

Published · 4 min read

We stopped writing prompts. Now every task starts with a form.

On tunyt, every AI task now starts with a file called prompt.yaml, filled in before the session begins. What each field is for, why the approval field matters most, and what internal testing showed about tokens, with the number I'm not publishing yet.

Most AI sessions start with one sentence, while the real context stays in my head. The agent has to ask what I meant or guess, and tokens go on finding out what I already knew.

So on tunyt we stopped writing prompts. Every task starts with a file called prompt.yaml that you fill in before the session. The agent reads it first.

What's in it

It has eleven fields. Each one answers a question the agent would otherwise ask or guess.

title: "Show future hosted events on the host profile"
type: feature        # feature | bug | refactor | perf | review | question
apps: [server, web]  # anything not listed stays untouched

objective: "A host's upcoming events stay visible on their public profile
            until the event's end time has passed."
context:
  - "Profile page only lists events where date <= now, so future ones vanish."
scope:
  - "the public profile page, 'Currently happening' section"
out_of_scope:
  - "apps/crm and apps/mobile"
constraints:
  - "No visual changes, logic only"
acceptance:
  - "Host with an event starting tomorrow: it shows under Upcoming, not Past"
  - "An event that ended an hour ago moves to Past"
approval:
  - "Any visual or copy change"
delivery:
  commit: ask
  pr: none

That's the template's own example, trimmed a little. The blank version has a comment above every field saying what goes there, with a good and a bad example.

The fields

type picks the procedure. There are six: feature, bug, refactor, perf, review and question. A bug means the agent fixes it. A review or a question means it doesn't edit anything. One word settles whether I want a change or an answer.

objective is the outcome. Say what should be true when it's done and leave the how to the agent. "Change the where clause in the host repository" is a bad objective. "A host's upcoming events stay visible until the event's end time has passed" is a good one. The first makes the agent do what I said even when I'm wrong about where the bug is. The second lets it find the real cause.

apps and out_of_scope are two fences. One says where to work. The other says what not to touch even when it looks related. With a CRM, a web app, a mobile app and a server in one repo, "looks related" is where surprise diffs come from.

acceptance has to be checkable. Each line is written as "when I do X, I see Y." "Works correctly" can't be tested. "An event that ended an hour ago moves to Past" can.

approval is the field I'd keep if I could only keep one. For anything listed there, the agent stops and asks: visual changes, migrations, writing a plan, committing, opening the PR. Those get decided before the session starts.

delivery stops the agent doing more than I asked. Commit is ask, parts or none. The PR is none or open-to-staging. The agent never merges.

Why the file resets

When a PR merges, CI resets prompt.yaml to the blank template. It's my favourite detail. Git already keeps the history, so the file doesn't have to. A stale prompt from last week is worse than none, because the agent reads it first and believes it. Every task starts blank, and nobody has to remember to clear it.

What it did to tokens

In our internal testing, the same task used fewer tokens when it started from a filled-in prompt.yaml than when it started from a sentence.

I'm not publishing a number yet, because I'd have to say which tasks, how many runs and which models. The claim is narrow: same task, fewer tokens, in our testing, on our repo.

The reason is simple enough that I believe it. A clearer brief means fewer follow-up questions and less rework. Fewer questions means fewer round trips, and less rework means fewer attempts.

What it doesn't do

It doesn't fix a vague objective. If I don't know what I want, the form just records my confusion neatly.

It's an extra step before every task, and for a one-line change that's often too much. A form filled in carelessly is worse than none.

And it's one repo and one team. I lead five people on tunyt, and agents write a lot of our code, which is why I wanted decisions made before the session. I don't know yet if the form suits a team that works differently.

Where it comes from

I wrote earlier about writing my judgment down because I can't read every line. This is the same idea for a single task. The rules in the repo cover what's always true. The form covers what's true today.

By , CTO of tunyt

← All writing