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 ✅ 
Build a web app for a yoga studio. The owner manages class bookings. Students see available classes and book directly. Start with the booking screen.
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 ✅ 
Make the header sticky, change the background to #F5F5F5, and add 16px padding between the cards
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 ✅ 
Add a way for people to create posts

Now add a feed that shows the most recent posts

Add a like button to each card in the feed
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.
Replicate this exactly: [paste image]. Match the spacing, fonts, and colors.

Make the card component look like this: [paste image]

Style the whole app like this: [paste image]. Keep it minimal.

Fill the pricing section with the text from this image: [paste image]
No screenshot? Describe the vibe: “minimal,” “premium,” “playful,” “dark mode.”

​
Give it URLs

Paste a URL and Anything screenshots the page for visual reference. 
Make my pricing page look like this: https://example.com/pricing
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. 
Look up the ScrapeCreators docs and use their API to grab X posts
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 Discussion mode to plan with the agent, then build step by step.
  1. Switch to Discussion mode
  2. Describe your idea at a high level
  3. Let the agent break it into a plan
  4. Switch back and build one piece at a time

​
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: 
light gray subtitles with some space between them and the title
✅ Exact values: 
#d3d3d3 subtitles, Inter font, 32px title, 24px subtitle, 12px gap

​
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. 
Trace the checkout flow from when the user clicks "Buy" to the confirmation page. Explain each step.
Then: 
Now add a promo code field before payment.
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. 
Break the dashboard into separate pieces for the sidebar, header, and main content
Smaller pieces are easier for the agent to update later.

​
Simplify

Ask the agent to audit your project: 
Look through this project and find anything that could be simplified or cleaned up

​
Reference old versions

Anything remembers version history. Something used to work and now doesn’t? Tell it. 
The paste image feature worked in a previous version when the page was selected. Bring that back.

​
Transfer style

Make one part of your app match another: 
Make the settings page look like the dashboard — same cards, spacing, fonts
Keeps things consistent as your app grows.

​
Protect what works

Tell the agent what not to touch: 
Update the pricing section only. Don't change the header, footer, or anything else.

​
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 a third-party 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 Discussion mode before you build. What you discuss gets added to context, so the agent executes with your plan in mind. Best for: 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.
Anything is the most reliable agent on the market. 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.