Skip to main content
Good prompts turn Noah into a focused teammate instead of a guessing machine. On this page you will learn how to describe what you want Noah to build, how to use the prompt box controls, and how to iterate until your smart contracts, dapps, and apps match what you had in mind. Noah prompt box

​
The Noah prompt box

The prompt box is where you tell Noah what to build. It has two main parts:
  • Modes (tabs at the top)
  • Action icons (buttons on the right side)

​
Modes

Use modes to tell Noah what kind of project you want. Each mode tunes how Noah structures the output, scaffolds files, and thinks about the user experience.
  • Full Stack Dapp: Ask for full web dapps that include smart contracts, frontend, and basic backend glue. Great when you want Noah to design the full experience from wallet connect to on‑chain actions.
  • Solana Program: Focus on on‑chain logic only. Use this mode when you care most about the program accounts, instructions, and security, and you plan to wire the UI yourself or later.
  • Mobile: Generate mobile-first apps that talk to your contracts or web APIs. Use this mode when the primary surface is iOS/Android rather than a browser.
  • Games: Ask for game-like experiences (on-chain or off-chain) such as loot systems, turn-based logic, or casual mini‑games. Noah will bias towards game loops, entities, and state updates.
You can switch modes between prompts. If the project shape is wrong, change the mode first, then refine your prompt.

​
Action icons

The icons on the right side of the prompt box unlock extra power:
  • Style and UX controls: Ask Noah to focus on design details such as layout, theming, or animations without rewriting your business logic.
  • Attachments: Attach files or other context when you need Noah to respect an existing codebase, API schema, or design spec.
Use these tools when a plain text prompt is not enough context for Noah to make safe changes.

​
Core prompting principles in Noah

​
1. Lead with the user goal

Start every prompt by explaining what your end user is trying to do, not just what code you want. Bad: 
Add a staking contract.
Better: 
Create a staking system where users lock SOL for 30, 90, or 180 days and earn tiered rewards. Show the current APY and lock-up period clearly in the UI.
When Noah understands the user journey, it can choose better APIs, components, and error states.

​
2. Specify chain and contract surface

Tell Noah which chain you are targeting and what the contract should expose:
  • Program or contract type (e.g. Solana program)
  • Key instructions / methods
  • Accounts, PDAs, or state you need
  • Events or logs that off‑chain clients will consume
Example: 
On Solana, build a voting program for a DAO. Each proposal has a title, description, and deadline. Members can vote yes/no once per proposal based on their token holdings. Emit events when proposals are created and when voting closes.

​
3. Describe UI and integrations

For Full Stack Dapp or Mobile modes, include how users interact with the system:
  • Wallet flow (connect, sign, network errors)
  • Main screens or tabs
  • Any external APIs, indexers, or backends Noah should integrate with
Example: 
Create a single-page dashboard for the DAO voting program. Show active proposals in a list with remaining time, yes/no counts, and my voting status. Include a modal to create new proposals that calls the on-chain program. Integrate with a Solana wallet adapter.

​
4. Add acceptance criteria

Tell Noah how you will decide if the result is “done”:
  • Performance or latency expectations
  • Error states that must be handled
  • Tests that must pass
Example: 
Include unit tests for the voting program instructions and at least one integration test that simulates creating a proposal and casting votes from two members.

​
Prompt patterns you can copy

Use these starting points and adapt the details to your project.

​
Full Stack Dapp prompt

Mode: Full Stack Dapp
Chain: Solana

Build a token launchpad dapp where project owners can create a sale for their SPL token, and users can contribute SOL during a fixed window.

Requirements:
- Landing page explaining how the launchpad works
- Sale detail page with progress bar, hard cap, and time remaining
- Wallet connect flow using Solana wallets
- On-chain program to store sale config and contributions
- Prevent contributions after the sale ends
- Include basic tests for the program and a README explaining how to run locally

​
Solana Program prompt

Mode: Solana Program
Chain: Solana

Create a treasury management program for a DAO.

Program requirements:
- Store a list of approved signers and a spending limit per proposal
- Support instructions to create a spend proposal, approve it, and execute it
- Enforce that at least 3 signers approve before funds move
- Emit events on proposal creation, approval, and execution
- Add tests that cover both successful flows and common failure cases

​
Mobile app prompt

Mode: Mobile
Chain: Solana

Build a React Native wallet companion app that surfaces analytics for a user’s NFT portfolio.

Requirements:
- Connect wallet via deep link or QR
- Show floor price, last sale, and rarity for each NFT
- Separate tabs for collections and individual assets
- Smooth scrolling list suitable for hundreds of NFTs
- Screen for viewing a single NFT with metadata and recent activity

​
Games prompt

Mode: Games
Chain: Solana

Design a simple on-chain turn-based game where two players take turns placing tokens on a 3x3 grid (tic-tac-toe).

Requirements:
- Program accounts to store game state, players, and winner
- Instructions to create a game, join, and play a move
- Validation to prevent invalid moves and moves after game end
- Basic web UI that shows the board, whose turn it is, and a “Play again” flow
Noah AI may make mistakes. Always review generated smart contracts, tests, and deployment scripts before using them with real funds.
If Noah’s output is far from what you expected, copy your last prompt, mark what was unclear, and resend a revised version. Clearer prompts almost always lead to dramatically better results.

​
FAQ

Include the user’s goal, the chain and contract surface, any important UI flows or integrations, and clear acceptance criteria. More context helps Noah make better architectural and UX decisions.
No. You can switch between modes at any time. Choose the mode that best matches what you are asking for (for example, Full Stack Dapp, Solana Program, Mobile, or Games) and adjust if the project shape feels wrong.
Yes. You can keep refining by sending follow-up prompts that describe what should change, such as adjusting UI layout, updating business rules, or extending on-chain logic. Noah will update the project based on your new instructions.
Always review generated smart contracts, tests, and deployment scripts before using them with real funds. Treat Noah’s output as a starting point and apply your own security reviews and best practices.
Copy your last prompt, highlight what was unclear or missing, and send a revised version with more explicit requirements. Iterating on the prompt almost always leads to significantly better results.