Skip to main content
You build by chatting. Better prompts, better apps. Here’s what works.

​
Your first prompt

Tell Anything what you’re building, who it’s for, and what the first screen should look like. ❌ landing page ✅
Context upfront means less back-and-forth. Mention: web or mobile, who uses it, what they do.

​
Be specific

Say what you want. Structure, colors, features, behavior. ❌ make it look better ✅
Use real content. Actual product names, real prices, your copy. Placeholder text hides layout problems.

​
One change at a time

Don’t build everything in one prompt. One feature, test it, next feature. ❌ Make a social media site with login, posts, feeds, likes, and friend invites ✅
You’ll move faster and catch problems earlier.

​
Use images

Paste screenshots into the chat. Anything sees them and uses them as reference.
Mac shortcut: Control + Command + Shift + 4 to screenshot, then Command + V to paste.
No screenshot? Describe the vibe: “minimal,” “premium,” “playful,” “dark mode.”

​
Give it URLs

Paste a URL and Anything screenshots the page for visual reference.
Works for design inspiration, documentation, or a competitor’s feature you want to match. Tell the agent to search when it needs info you don’t have handy.
It searches, reads the results, and builds with that context.

​
Say what, not how

Tell the agent what your app should do. Skip the technical details. The agent knows what works. ❌ Create a React component with useState hooks and a useEffect for fetching data from a REST API ✅ Show a list of orders with a search bar to filter by date

​
Plan first

Have a detailed spec from ChatGPT or Claude? Don’t paste it all in. Use Plan mode to work out the approach with the agent, then build step by step.
  1. Switch to Plan mode
  2. Describe your idea at a high level
  3. The agent explores your project and writes a step-by-step plan without changing any code
  4. Switch to Thinking mode and ask the agent to build the first piece
If you just want to ask the agent a question or get its take on something, use Discussion mode instead. Discussion never touches your code.

​
Use threads

New feature? New thread. Each thread has its own context, so the agent stays focused.
  1. Build the foundation in one thread
  2. Start a new thread for each feature
  3. Work across threads in parallel
See Threads.

​
Think harder

Complex problem? Give the agent more room to reason.
  • Switch to Thinking mode in the mode selector
  • Or just say: “Think step by step about how to approach this before making changes”
Deepthink2 Pn

​
Precise details

Exact values or plain English. Both work. ✅ Plain English:
✅ Exact values:

​
Fix errors

Describe what’s wrong. What you expected. What happened instead. Screenshot if possible.
Anything recovers from errors on its own. Check the error logs in the bottom bar.
❌ It's still not working ✅ When I click submit, nothing happens. It should save the form and go to the next page. ❌ The date picker is wrong ✅ This date picker [screenshot] shows 1/9/2025 when I select 1/10/2025. Fix it? Paste error messages from the logs straight into chat. The agent can usually sort it out.

​
Understand before changing

For complex features, ask the agent to explain first. Then make changes.
Then:
The agent has the full picture in context. It makes smarter changes.

​
Refactor

Refactoring means reorganizing code without changing what it does. Useful when a page gets complex.
Smaller pieces are easier for the agent to update later.

​
Simplify

Ask the agent to audit your project:

​
Reference old versions

Anything remembers version history. Something used to work and now doesn’t? Tell it.

​
Transfer style

Make one part of your app match another:
Keeps things consistent as your app grows.

​
Protect what works

Tell the agent what not to touch:

​
Planning your app

Everything above is about how to prompt. This section is about how to think about building. What order, when to go broad vs. deep, how to keep things stable. These are patterns from decades of software development. You don’t need to code, but they’ll make you better at building with Anything.

​
Top down vs. bottom up

Top down: specify everything upfront, perfect the details. Bottom up: get one part working, add the next piece. Top down works for simple apps. You can often describe the whole thing in one prompt. Bottom up works better when it’s complex. Build the foundation, test, add a feature, test. You’ll switch between both.

​
Front to back vs. back to front

Front to back: make it look right, then make it work. Back to front: get the logic working, then make it look good. Front to back is usually better. Once the UI exists, the agent can infer the backend. Back to front is better when you’re testing something risky like an external API, an unknown integration. Get the hard part working first. Start with whatever carries the most risk.

​
One prompt, one feature

Many small fixes in one prompt? Fine. Complex feature? One per prompt. It might need changes to the UI, backend, and database all at once. When in doubt, focus on one thing.

​
Stay stable

Get to a working base. Test it. Add a feature. Test it. If something breaks, you know what caused it. You can revert to the last working version. If you add too many things at once and two break, good luck figuring out which one.

​
Plan then execute

Use Plan mode before you build. The agent writes a step-by-step plan without changing any code. What you go over there gets added to context, so when you switch to Thinking mode and tell it to build, it executes with your plan in mind. Best for: complex features, uncertain approaches, comparing options, debugging.

​
Test as you go

Three things to check after every change:
  1. UI: does it look right?
  2. Behavior: does it do what it should when you click, type, submit?
  3. Data: is the right data in the database?
Test after each change. Not at the end.
Simple app? Have fun. You’d be surprised what one prompt can do. As things get complex, these principles keep the agent on track and let you build much bigger things.