I'm leony, an indie maker. I run kimi-k2.net, a small independent web chat for Kimi models (it calls the Moonshot AI API under the hood, but it isn't affiliated with Moonshot AI). New accounts get two free conversations. That limit forced me to think hard about one question: how do you get a finished result out of an LLM in as few turns as possible?
The answer turned out to be useful well beyond my own site, so here's the template I now use with any chat model — Kimi, or anything else.
Why "few turns" matters
Most wasted LLM sessions follow the same pattern: a vague first message, a generic answer, then five rounds of "no, I meant…". Each round costs time (and on paid tools, credits). If you front-load the decisions, the model can usually get it right in one or two passes.
The four-block prompt
I structure every serious request into four blocks:
- Objective – one sentence: what you want and who it's for.
- Verified context – the data, code, or notes the model should rely on. Paste it or attach it; don't make the model guess.
- Constraints – what not to assume, what to avoid, which tools/versions to target.
- Output schema – the exact shape of the answer: a markdown table, a single shell command, a file, a numbered plan.
Then add one line at the end: "Before answering, list your assumptions and any edge cases you're unsure about." That single instruction catches most misunderstandings in the first reply instead of the fourth.
(The Kimi K3 guide on kimi-k2.net uses the same idea — Prompt → Context → Format → Verify — with copyable templates.)
Example 1: a shell command you can actually run
Vague:
find big log files and zip them
Four-block:
Objective: Generate one shell command for macOS/Linux (bash).
Context: Log files live anywhere under my home directory and end in .log.
Constraints: Only files larger than 10MB. Don't delete originals. Avoid GNU-only flags if possible.
Output: The command on one line, then a 3-bullet explanation of each part.
Before answering, list assumptions and edge cases (spaces in filenames, symlinks).
The second version almost always produces something like a find ~ -name "*.log" -size +10M -exec gzip -k {} \; style answer plus a note about filenames with spaces — which is exactly the edge case you'd otherwise discover the hard way.
Example 2: from a CSV to a chart page
This is one of the example prompts on the kimi-k2.net homepage, and it's a good stress test:
Objective: Analyze the attached CSV of housing prices and build a single-file web page that visualizes it.
Context: Columns are date, city, price_usd, sqft. (attached)
Constraints: Plain HTML + one CDN chart library. No build step. Handle missing values.
Output: 1) a 5-line summary of the distribution and trend, 2) the complete HTML file in one code block.
Before answering, list assumptions about the data.
Two things make this work in one turn: telling the model the column names (so it doesn't hallucinate a schema), and asking for the summary before the code (so you can sanity-check its reading of the data before trusting the chart).
Example 3: comparing two documents
Compare the Q3 reports (attached) and summarize the key performance indicators in a markdown table.
Add an output schema — | Metric | Company A | Company B | Change vs Q2 | Source page | — and the "source page" column forces the model to point at where each number came from. That makes verification fast, which matters because any LLM can misread a table.
Use the second turn for review, not rework
If you only have two turns (or just want to stay efficient), don't spend the second one re-explaining the task. Spend it on a review pass:
Review your previous answer. Check each number/command against the context I gave.
List anything you're not certain about, then output the corrected final version only.
This turns turn #2 into a self-check instead of a do-over.
A few habits that save the most time
- Paste the error, not a description of the error. Stack traces beat "it doesn't work".
- Pin versions. "Python 3.11, pandas 2.x" removes a whole class of wrong answers.
- Ask for one artifact per message. One script, one table, one plan — combine later.
- Verify anything important. Models can be confidently wrong about facts, numbers, and APIs.
Try it
If you want to test the template on Kimi without setting up an API key, the Kimi Chat workspace gives you two free conversations after a Google sign-in; extra usage is one-time credit packs that don't expire (pricing). If you'd rather call the API directly, the site also has an independent Kimi K2 developer guide — just double-check model names and prices against Moonshot AI's official docs, since those change.
Either way, the four-block prompt works with any chat model. Front-load the decisions, ask for assumptions, and use your follow-up for review. Your future self (and your credit balance) will thank you.
What's your go-to structure for one-shot prompts? I'd love to steal a few ideas in the comments.
Top comments (0)