#Building apps
Describe an app you want, and Arachne builds something you can open, use, and refine in plain language.
#Overview
Arachne can build a working app from a description. You say what it should do and how it should look, and Arachne produces something you can open and use — not a sketch or a spec, but a real, functioning result you can put your hands on. From there you keep talking to it in plain language until the app does what you want.
This is where Arachne goes beyond answering. Building an app is hands-on, multi-step work, and Arachne handles it the way it handles everything else: it understands the outcome you described, does the work, checks its own result, and delivers a finished artifact you can return to. You describe the goal; Arachne finds the path.
#What you can do
- Build a working app from a plain-language description. Tell Arachne what the app is for, what it should do, and the kind of look you want — Arachne builds it.
- Open and use the result immediately. What Arachne produces is something you can run and interact with, not just read about.
- Iterate in conversation. Ask for changes, additions, and fixes in plain language, as many rounds as it takes, until the app is right.
- Get a verified result. Arachne checks its work before it reports the app as done, so a finished app is one that actually works.
- Keep it as an artifact. The app is saved so you can find it again, reopen it, build on it later, and export or download it.
- Choose how much freedom Arachne has while it builds, using the permission levels — and stop at any moment.
#How to use it
- Describe the app and its purpose. Say what the app is for and who will use it. Lead with the outcome: "a tool that does X," not a list of steps to build it.
- Say how it should behave and look. Call out the features that matter, the way you want it to feel, and anything it must or must not do. The more concrete you are about the result, the closer the first version lands.
- Hand over any details you already have. If you have content, constraints, examples, or a reference you like, give them to Arachne up front so it builds from the right starting point.
- Pick a permission level and watch the first build. Watching the first run lets you steer early and catch anything heading the wrong way. You can change the level at any time, and stopping always works immediately.
- Open the result and try it. Use the app the way it is meant to be used and notice what is missing or off.
- Refine in plain language. Ask for each change in conversation — "add this," "change that," "this should behave differently" — and let Arachne adjust. Repeat until it is right.
- Reopen it whenever you need it. The app is saved as an artifact you can return to, reuse, or download later.
A clear description of what the app does beats a long description of how to build it. Tell Arachne the result you want and let it work out the construction.
#How it differs from building a site
Building an app and building a site are close cousins — both start from a description, both arrive as something you open and use, and both refine in plain language. The difference is what you are after:
| Building a site | Building an app | |
|---|---|---|
| You want | Pages and content people read and move through | Something people do things with |
| The center of it | The look and the information | The behavior and what it lets you accomplish |
| You describe | What it should say and look like | What it should do and look like |
If your goal is a place that presents information, ask Arachne to build a site. If your goal is a working tool that performs a task, ask it to build an app. In practice you can simply describe the outcome you want, and Arachne builds the right kind of thing.
Both are saved the same way — as artifacts you can find, reopen, reuse, and download. Whichever you build, the result is yours to come back to.
#Examples
What you ask:
Build me a small app for tracking the books I'm reading — title, author,
how far I've got, and a rating when I finish.What you see: Arachne builds a working app you can open right away, with a place to add books and record progress and ratings. It arrives as a saved artifact you can reopen later, and you can ask for changes — "add a notes field," "let me sort by rating" — in plain language.
What you ask:
Make a tip calculator I can use on my phone — enter the bill, pick a
percentage, and split it across a few people.What you see: A clean, usable calculator that does exactly that. You try it, then refine: "round each share up," "remember the last split I used." Each request is applied and the updated app is ready to use again.
What you ask:
The book tracker looks good, but make the finished books move to a
separate "Read" list and show my average rating at the top.What you see: Arachne adjusts the existing app — a separate list for finished books and an average rating on display — verifies the change, and hands back the updated, working app. Your earlier version's progress carries forward.
#Tips
- Lead with the outcome, not the build. Describe what the app should let someone do; let Arachne decide how to make that happen.
- Refine in small, clear rounds. One focused change per request is easier to land cleanly than a long list — and you see the effect of each before moving on.
- Watch the first build at a cautious permission level when the app matters, then give more freedom once you trust the direction.
- Treat the result as something you keep. The app is a saved artifact — reopen it, build on it, and download it when you want it outside Nourva.