Build with AI: a field guide

02The big picture

How AI systems fit together.

A model on its own only predicts text. Products become useful when you wrap it with an interface, clear instructions, your own data and tools it can use.

01 · Person

Someone with a problem

A resident, a dispatcher, a volunteer. Start from what they need, not from the tech.

02 · Your app

The interface

A chat, a map, a dashboard, a WhatsApp bot. Lovable, Streamlit or your own code.

03 · Model

The reasoning engine

An LLM such as Claude on Amazon Bedrock. It reads, decides and writes.

Instructions

System prompt

Who it is, what it must and must not do, the format to answer in.

Knowledge · RAG

Your data

Documents, CSVs and databases it can search, so answers are grounded in facts, not memory.

Tools · MCP

Actions

APIs it can call: weather, maps, send an SMS, write to a sheet. Tools are what turn a chatbot into an agent.

Most AI products are these five parts. Your prototype only needs the smallest version of each.

03Agents

From chatbot to agent.

Start with the simplest thing that works. A single well-written prompt beats a complicated agent you can’t debug. Add tools and loops only when the task needs them.

01
Goal
What should be true at the end?
02
Plan
Break it into the next step.
03
Act
Call a tool, run code, search.
04
Observe
Read the result. Done, or loop?

A chatbot answers once. An agent keeps looping until the goal is met, using tools to act on the world. OpenCode is itself an agent: it plans, edits files, runs commands and reads the output.

04The build path

From idea to demo.

Hackathon prototypes win on a clear story, not on lines of code. Spend your time where the demo will show it.

01
Pick a person
One real person and one moment where they struggle. “Families in Ein Kerem during a wildfire”, not “climate”.
02
Research
Ask Perplexity what exists, what data is out there and what failed before. Ten minutes, not an hour.
03
Build the smallest thing
One screen, one flow, one model call. Hard-code what you must. Make it work before making it nice.
04
Test with real data
Run it on the real dataset or a real example. Fix the one thing that breaks the story.
05
Demo the story
Problem, who it helps, live demo, what’s next. Two minutes. Record a backup video.

05Toolkit

What to use, and when.

You don’t need all of these. Pick one from each row you actually need, and don’t switch tools halfway through.

Research

Understand the problem, find data, check facts.

Build with a coding agent

You (or someone on the team) can run a terminal or an editor.

Build without code

You want a working app from a description, fast.

Models and agents

The “brain” of your solution and the parts that let it act.

Interface, data and hosting

Turn the idea into something people can click.

Show it

Explain what you built in two minutes.

06Setup

OpenCode + Amazon Bedrock.

OpenCode is an open-source coding agent for your terminal. Connect it to Amazon Bedrock with an API key and it can use Claude and other models to write, run and fix code with you.

Step 01

Install OpenCode

terminal

# macOS / Linux
curl -fsSL https://opencode.ai/install | bash

# or with npm (macOS, Linux, Windows)
npm install -g opencode-ai

# or with Homebrew
brew install anomalyco/tap/opencode

Step 02

Add your Bedrock key and start it

Prefer not to use the terminal for the key? Start opencode, type /connect, search for Amazon Bedrock and paste the key there.

macOS / Linux

# Paste your Bedrock API key and region (from your table guide)
export AWS_BEARER_TOKEN_BEDROCK="paste-your-key-here"
export AWS_REGION="us-east-1"

# Start OpenCode inside your project folder
mkdir my-project && cd my-project
opencode

Windows PowerShell

$env:AWS_BEARER_TOKEN_BEDROCK = "paste-your-key-here"
$env:AWS_REGION = "us-east-1"
mkdir my-project; cd my-project
opencode

Step 03

Prefer the browser? Open OpenCode web

Starts an OpenCode session in your browser instead of the terminal. Run it after setting the key, and keep the terminal open while you work.

terminal

# In the same terminal, inside your project folder
opencode web

Step 04

Pick a model and get going

inside opencode

/models      pick a model, e.g. a Claude Sonnet model on Amazon Bedrock
/init        let it read the project and write AGENTS.md
Tab          switch between Plan (thinks, no edits) and Build (edits files)

Optional: save the region in the projectShow

Put an opencode.json in the project root so everyone on the team uses the same region. Settings in this file win over environment variables. Keep the key itself out of it.

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": { "region": "us-east-1" }
    }
  }
}

Keep the key secret. Never paste it into a prompt, a slide, a screenshot or a file you push to GitHub. If /models shows no Bedrock models, check the key and region first, then ask a mentor.

07Prompting

Prompts that get it right.

Treat the model like a brilliant new teammate who knows nothing about your project. The more context and the clearer the ask, the better the result.

01

Role

Who should the model be?

You are a senior Python developer who builds simple, readable dashboards.

02

Context

What does it need to know?

We have a CSV of historical earthquakes in Israel. Columns are in data_dictionary.json.

03

Task

What exactly should it do?

Build a Streamlit app that maps events and filters them by type and year.

04

Constraints

What must it avoid or respect?

One file, no paid APIs, runs with `streamlit run app.py`. Ask before adding dependencies.

05

Format

What should the answer look like?

First a short plan as bullets, then the code, then how to run it.

06

Examples

Show, don’t only tell.

Here is one row of the data and the kind of summary card we want: …

Copy this template

prompt template

You are a {role}.

Context:
{what the project is, who it's for, which files or data to use}

Task:
{one clear thing to do now}

Constraints:
- {tech stack, time limit, what not to touch}
- Ask me before adding new dependencies.

Output:
First a short plan as bullet points. Wait for my OK, then build it.

Plan before you build
Ask for a plan first (in OpenCode press Tab for Plan mode), fix the plan, then let it build.
Small steps win
One feature per prompt. Run it, check it, commit, then ask for the next one.
Give it the real data
Point it at the actual file and data dictionary instead of describing the data from memory.
Paste the error
When something breaks, paste the full error and what you expected. Don’t just say “it doesn’t work”.
Ask it to check itself
“List what could be wrong with this” or “write a quick test” catches mistakes early.
Verify facts
Models can sound sure and be wrong. Check numbers and claims against a source before you present them.

08Go deeper

Keep learning.

Free, trustworthy material we recommend after the event, plus the guides we handed out at past build nights. Every event toolkit lives at jerusalemai.com/toolkit.

Prompting

Agents

Tools and platforms

From our events

Build with AI,a field guide.