Start with one safe AI workflow. Finish with small AI apps, tests, review gates, RAG basics, agent patterns, deployment checklists, and a portfolio capstone.
AI built by people, for people.
This book is the free public side of DWAI. It is not a teaser and it is not just a prompt pack. It is a path: from day one, through developer foundations, into AI-assisted coding, AI app patterns, responsible agents, evaluation, and safe shipping habits.
It does not promise a job, income, instant mastery, productivity, business results, or a guaranteed personal outcome. It gives you a practical curriculum, projects, review gates, and a way to keep learning without handing authority to AI.
Before you paste anything into an AI tool: use placeholders for names and private details. Do not paste passwords, API keys, 2FA codes, recovery codes, private tokens, card details, medical records, legal documents requiring advice, regulated financial records, customer data, or sensitive account access.
Do not try to become advanced by skipping the basics. The path is layered:
If a chapter feels too hard, mark HOLD, reduce the task, and repeat the smallest working version. That is what developers do.
An AI developer is not someone who blindly asks a model to “make an app.” An AI developer can:
The goal is not to memorize everything. The goal is to become a builder who can learn, test, debug, and ship small useful AI systems responsibly.
AI can help you learn faster, draft faster, compare options, explain code, write small programs, review mistakes, and design workflows. It cannot take ownership for you.
Your first developer habit is not coding. It is owner control.
Use this rule everywhere:
AI drafts and explains. I decide, test, approve, and own the result.
Your first artifact:
# My AI Developer Boundary Note
I am using AI to learn and build.
I will not paste secrets, passwords, API keys, 2FA codes, customer data, private
records, or sensitive account access into chat.
I will not let AI spend money, publish, send, delete, deploy, change accounts, or
make commitments without explicit owner approval.
I will test important outputs before trusting them.Before code, learn the loop. Open ChatGPT, Claude, Gemini, or another AI chat tool and choose one non-sensitive task: organize notes, explain a concept, plan a tiny project, research a tool, or draft a README.
Paste this:
I am new to using AI as a system. Help me build one tiny routine from a real task.
My task:
[turn messy notes into a plan / draft an email / research a decision / learn a topic]
My messy input:
[paste non-sensitive notes, or replace private details with placeholders]
My goal:
[what I want back]
My red lines:
Do not send messages, post publicly, spend money, change accounts, delete anything,
make commitments, make final decisions for me, ask for secrets, or continue if my
input contains sensitive/private material that should be replaced with placeholders.
Do not make therapy, counselling, diagnosis, treatment, medical, legal, financial,
tax, crisis, regulated-advice, or guaranteed-outcome claims.
Please give me:
1. a plain-English name for this workflow;
2. the inputs you need next time;
3. a useful first draft or organized output;
4. a checklist I can use to review it;
5. anything risky that needs owner approval;
6. one sentence I should add to my context card for next time.Review the output with three labels:
The developer habit is the loop: ask, inspect, test, update.
Do not ask AI to “teach me everything.” Ask for a loop:
Teach me this like a practical system.
Topic/workflow: [what I want to learn]
Outcome I want: [what I should be able to do]
My current level: [beginner/intermediate/what I already know]
Constraints: [time, tools, budget, platform, risks]
Please:
1. explain the mental model;
2. show the workflow step by step;
3. give 3 examples;
4. quiz me to find gaps;
5. correct my understanding;
6. give me one small practice task;
7. define how I verify whether I did it correctly;
8. suggest how to update my notes/prompts after the attempt;
9. keep risky actions draft-only and flag anything that needs owner approval.
Do not make therapy, counselling, diagnosis, treatment, medical, legal,
financial, tax, crisis, regulated-advice, or guaranteed-outcome claims.For every topic in this book, use the same pattern:
You are not learning if you cannot explain the output without the AI.
Developer work touches risky surfaces quickly. These require owner approval:
sudo, rm -rf, recursive permission changes, or
install scripts piped into a shell.If unsure, HOLD.
Create one notes file. Call it LEARNING-LOG.md.
Use this structure:
# Learning Log
## Today’s topic
## What I tried
## What worked
## What failed
## Error messages I saw
## What I think the error means
## One thing I can now explain
## One thing still unclear
## Owner gates / risks noticedA full AI developer is built by repeated logs, not by one perfect tutorial.
A beginner-safe workspace has four layers:
Suggested local folder structure:
ai-learning/
00-notes/
LEARNING-LOG.md
CONTEXT.md
01-html-css-js/
02-python/
03-api-basics/
04-ai-api-app/
05-rag-demo/
06-agent-demo/
07-capstone/Do not put API keys, passwords, private exports, client data, or personal records inside practice folders.
The Terminal lets you move through folders and run tools. Learn these ideas first:
pwd means “where am I?”ls means “what is here?”cd folder-name means “move into this folder.”mkdir folder-name means “make a folder.”touch file-name means “make a blank file.”cp source destination copies.mv source destination moves or renames.Beginner safety rules:
sudo until you know why elevated permission is
required.rm -rf in tutorials unless you fully understand
the path and have a backup.Practice task:
terminal-practice.notes.md inside it.PASS means you can explain the folder path and undo the test safely.
Your editor is where code becomes visible. Learn these moves:
Ask AI:
I am new to VS Code. Explain the file tree, integrated terminal, search, source
control, and Problems panel like I am learning to build AI apps. Give me one
10-minute practice task and a PASS/HOLD checklist.Practice task: open your ai-learning folder, create
CONTEXT.md, and write:
# Project Context
I am learning to become an AI developer.
I prefer small steps, explanations, tests, and owner gates before risky actions.Git tracks changes. GitHub can store a remote copy. You do not need a public repo to learn. Private first is the default.
Learn these Git concepts:
.gitignore — files Git should not
track, especially .env.First Git practice:
Create a private practice repo. Add README.md, CONTEXT.md, and LEARNING-LOG.md.
Commit only safe files. Do not push public. Do not include API keys or .env files.Before every commit, ask:
You can build an AI app without being a designer, but you need the basics of the web.
Mental model:
Project 1: build a local “AI Learning Dashboard” page.
Required files:
01-html-css-js/
index.html
styles.css
app.js
README.mdFeatures:
Acceptance criteria:
JavaScript makes web pages interactive. TypeScript adds types so mistakes are caught earlier.
Core ideas:
Minimal runnable JavaScript example:
const entries = [
{ note: "AI suggested a safer wording for my bio" },
{ note: "AI suggested changing billing settings" },
{ note: "AI helped explain a JavaScript error" },
];
function classifyEntry(entry) {
const riskWords = ["billing", "password", "secret", "deploy", "delete", "publish"];
const text = entry.note.toLowerCase();
const risky = riskWords.some((word) => text.includes(word));
return {
note: entry.note,
verdict: risky ? "HOLD" : "PASS",
reason: risky ? "Owner approval required before action." : "Safe as draft/review work.",
};
}
console.log(entries.map(classifyEntry));Run it with Node:
node app.jsTiny TypeScript upgrade:
type Verdict = "PASS" | "HOLD";
type Review = {
note: string;
verdict: Verdict;
reason: string;
};AI-assisted practice prompt:
Teach me JavaScript objects and functions using an AI learning log example.
Give me a tiny example, then ask me to predict the output before showing the
answer. Then give me one bug to fix and a PASS/HOLD checklist.You are ready to move on when you can read a small function, run it, change one line, and explain inputs, outputs, and possible failures.
Python is useful for scripts, data processing, automation, AI prototypes, and API experiments.
Core ideas:
Project 2: build a local learning-log summarizer without AI API calls.
Create summarize_log.py:
from pathlib import Path
import re
import sys
def summarize(path: Path) -> dict:
if not path.exists():
raise FileNotFoundError(f"Missing file: {path}")
text = path.read_text(encoding="utf-8")
words = re.findall(r"\w+", text)
headings = [line.strip("# ") for line in text.splitlines() if line.startswith("#")]
return {
"file": str(path),
"lines": len(text.splitlines()),
"words": len(words),
"headings": headings,
}
def write_summary(result: dict) -> Path:
output = Path("summary.md")
heading_lines = "
".join(f"- {heading}" for heading in result["headings"]) or "- None"
output.write_text(
f"# Summary
"
f"File: {result['file']}
"
f"Lines: {result['lines']}
"
f"Words: {result['words']}
"
f"## Headings
{heading_lines}
",
encoding="utf-8",
)
return output
def main() -> None:
if len(sys.argv) != 2:
raise SystemExit("Usage: python3 summarize_log.py learning_log.md")
result = summarize(Path(sys.argv[1]))
output = write_summary(result)
print(f"Wrote {output}")
if __name__ == "__main__":
main()Create learning_log.md:
# Day 1
I learned what PASS and HOLD mean.
## Mistake
I almost pasted private context. I used placeholders instead.Run:
python3 summarize_log.py learning_log.mdAcceptance criteria:
summary.md is created;AI apps are mostly data moving between systems.
Learn these terms:
Practice with a public no-auth API or a local mock first. Do not start with paid AI keys.
Your API checklist:
A developer is not someone who never sees errors. A developer is someone who can investigate errors calmly.
Debugging loop:
Testing loop:
Ask AI for help like this:
Here is the full error message and the smallest code example. Do not guess a fix
yet. First explain what the error means, what line matters, what assumptions you
need to check, and the smallest test I should run next.Never accept “try this” if neither you nor the AI can explain why.
AI writes better code when the target is clear. Before asking for code, write a small spec.
Spec template:
# Project Spec
## User problem
## Inputs
## Outputs
## Constraints
## Non-goals
## Safety / owner gates
## Acceptance criteria
## Test cases
## Files expectedA weak request says: “Build me an AI app.”
A better request says: “Create a local-only note classifier that reads sample notes, labels them PASS/HOLD/FIX, writes JSON output, includes tests, and does not call external APIs.”
Use AI as a pair programmer, not an owner.
Good coding prompt:
You are helping me learn. First explain the plan and file changes. Do not write
code until the plan is clear. Keep the project local-only. Avoid secrets, public
pushes, deploys, account changes, and destructive commands. Include tests or a
manual verification checklist. After code, explain the diff in beginner language.Code review checklist:
A diff shows what changed. Learn to read it before trusting AI-generated code.
Look for:
Practice prompt:
Review this diff like a cautious AI developer. Separate: expected changes,
unexpected changes, security risks, tests missing, docs missing, and PASS/HOLD/FIX
verdict. Do not approve deployment or public push.Project 3: ai-task-sorter.
Goal: a local script that reads a text file of tasks and sorts them into:
do_now;schedule;ask_owner;hold_risky.No AI API yet. Use rules first so you understand the workflow.
Acceptance criteria:
hold_risky;This teaches the pattern before adding a model.
Project 4: local “review queue.”
Goal: a small web page or local API that lets you paste a draft and mark it PASS, HOLD, or FIX.
Acceptance criteria:
This is the bridge from “I can write code” to “I can build a small tool.”
Every project needs a README.
README template:
# Project Name
## What it does
## What it does not do
## Why it exists
## How to run locally
## Test / verification steps
## Safety notes
## Known limits
## Next improvementsIf you cannot explain the project in a README, you do not understand it yet.
You do not need to know every model detail to start, but you need the mental model.
Key terms:
Developer habit: separate prompt, input data, model settings, output parser, and review criteria. Do not hide everything inside one magic prompt.
Before using a real paid key, read the provider docs and understand billing, privacy, and rate limits. If you use a real key:
.env to .gitignore;Practice path:
Runnable mock-first adapter in Node:
async function callAi({ prompt }) {
if (process.env.USE_REAL_AI !== "1") {
return {
text: `MOCK AI RESPONSE: ${prompt.slice(0, 80)}`,
source: "mock",
estimated_cost: 0,
};
}
const apiKey = process.env.DWAI_DEMO_AI_KEY;
if (!apiKey) throw new Error("Missing DWAI_DEMO_AI_KEY environment variable.");
// Replace this URL/body with the provider docs you choose.
const response = await fetch("https://api.example.com/v1/responses", {
method: "POST",
headers: {
"content-type": "application/json",
"authorization": `Bearer ${apiKey}`,
},
body: JSON.stringify({ input: prompt }),
});
if (!response.ok) throw new Error(`AI API failed with ${response.status}`);
return response.json();
}
callAi({ prompt: "Explain PASS/HOLD in one paragraph." })
.then(console.log)
.catch((error) => {
console.error(error.message);
process.exit(1);
});Run safely in mock mode:
node ai_adapter.jsOnly switch to real mode after the owner approves account creation, billing, provider choice, environment variable setup, and test budget.
Owner gate: creating provider accounts, adding billing, and using real keys are owner-approved actions.
AI text is flexible. Apps need predictable shapes. Structured outputs ask the model for data like:
{
"verdict": "HOLD",
"reason": "This touches deployment and needs owner approval.",
"next_action": "Review the deploy checklist before running commands."
}A schema defines what fields are allowed. Your app should validate AI output before trusting it.
Project 5: build a local draft reviewer.
Input: a draft note. Output: JSON with verdict,
risks, missing_context, and
next_action. Requirement: if output is invalid JSON, mark
HOLD and ask for repair.
Acceptance criteria:
RAG means retrieval-augmented generation. Plain English: the app finds relevant source material first, then asks the model to answer using that material.
RAG parts:
Safe beginner RAG project:
Project 6: “Ask my public notes.”
Runnable toy retrieval before embeddings:
NOTES = [
{"title": "Owner Gates", "text": "Deploys, billing, secrets, and public posts require owner approval."},
{"title": "Learning Log", "text": "Write what you tried, what failed, and what you can explain."},
{"title": "RAG Boundary", "text": "If sources do not support the answer, say HOLD: insufficient evidence."},
]
def score(query: str, text: str) -> int:
query_words = set(query.lower().split())
text_words = set(text.lower().replace(",", "").replace(".", "").split())
return len(query_words & text_words)
def retrieve(query: str, k: int = 2) -> list[dict]:
ranked = sorted(NOTES, key=lambda note: score(query, note["text"]), reverse=True)
return [note for note in ranked[:k] if score(query, note["text"]) > 0]
def answer(query: str) -> str:
sources = retrieve(query)
if not sources:
return "HOLD: insufficient evidence in the notes."
titles = ", ".join(note["title"] for note in sources)
combined = " ".join(note["text"] for note in sources)
return f"Based on {titles}: {combined}"
print(answer("Do deploys need approval?"))This is not production RAG, but it teaches the real shape: documents,
retrieval, cited sources, insufficient-evidence behavior, and eval
questions. Later you can replace the score function with
embeddings.
Acceptance criteria:
Tool calling lets a model ask software to do a defined task, such as search a file, calculate a value, or classify a record. This is powerful and risky.
Safe rules:
Beginner tool demo:
count_words(text);classify_owner_gate(text);format_markdown_checklist(items).Do not start with tools that send emails, delete files, deploy apps, move money, or change accounts.
An agent is a loop: observe, decide, act, review, continue or stop. Most beginner failures come from giving a loop too much authority.
Safe agent design:
Project 7: build a local review agent.
It can:
It cannot:
Runnable local agent loop:
RISK_WORDS = ["send", "publish", "delete", "deploy", "billing", "password", "api key", "medical", "legal"]
def classify(task: str) -> dict:
lowered = task.lower()
risks = [word for word in RISK_WORDS if word in lowered]
if risks:
return {"verdict": "HOLD", "risks": risks, "next_action": "Ask owner before action."}
if len(task.strip()) < 20:
return {"verdict": "HOLD", "risks": ["missing context"], "next_action": "Ask for goal, input, output, and red lines."}
return {"verdict": "PASS", "risks": [], "next_action": "Create a draft/checklist only."}
def run_agent(task: str, max_steps: int = 3) -> list[dict]:
log = []
for step in range(1, max_steps + 1):
result = classify(task)
log.append({"step": step, "task": task, **result})
break # This beginner agent reviews once, then stops.
return log
for event in run_agent("Draft a private launch checklist, do not deploy anything."):
print(event)The point is not autonomy. The point is a controlled loop with a maximum step count, readable logs, and HOLD behavior before risk.
Acceptance criteria:
“Looks good” is not enough. Evals are repeatable checks.
Types of evals:
Create an eval sheet:
# Eval Set
## Test ID
## Input
## Expected behavior
## Required verdict
## Why
## PASS/HOLD/FIX resultYour AI app is not serious until it has examples that can fail.
Developer safety expands the no-secrets rule.
Checklist:
.env is ignored by Git;If a key leaks, rotate it. Do not argue with the leak.
AI systems cost money and fail in normal ways.
Plan for:
Every AI feature should have:
Deployment means making software reachable outside your machine. That can be public and risky.
Before deployment:
Deployment is optional in this book. You can become a credible beginner AI developer with local demos, private repos, screenshots, walkthrough videos, and clear README files before touching public infrastructure.
Owner gate: public deploy, GitHub push, provider setup, billing, domain, DNS, and production data are not automatic learning steps.
Shipping is not the end. You need to know if the system still works.
Maintenance checklist:
Use a weekly self-update loop:
Review the last 7 days using only what I provide. Ask up to 5 clarifying questions
if needed. Then produce:
1. what changed;
2. what should update in my profile/context;
3. which goals, assumptions, prompts, or routines are stale and should be pruned;
4. which AI instructions, prompts, or review gates should change;
5. one simple next-week operating rhythm;
6. any risky actions that need owner approval.
Do not make clinical, medical, legal, financial, tax, crisis, or guaranteed-outcome
claims. Keep risky actions draft-only.Accept only updates you understand.
A beginner portfolio should show proof, not exaggeration.
For each project, include:
Do not claim client results, job-level mastery, medical/legal/financial expertise, or production reliability unless you have real evidence and permission.
Build in this order:
Each project should have:
Choose one real but safe workflow. Examples:
Capstone requirements:
# Capstone Requirements
## Problem
A clear user problem.
## User
Who this is for.
## Workflow
Input → AI/process → review → output → update.
## Features
Small and specific.
## AI feature
Prompt, structured output, retrieval, tool call, or agent loop.
## Safety
No secrets, no private data, no external side effects without owner approval.
## Tests/evals
At least 10 examples, including risky HOLD cases.
## README
How to run, verify, and understand limits.
## Demo
Screenshot, video, or local walkthrough notes.This is a realistic beginner route. Adjust pace, but keep the order.
Ask for help when:
DW AI Studio, mentors, friends, forums, docs, and other courses can all fit here. The free essentials are not hidden. Paid help is for speed, judgement, troubleshooting, adaptation, and accountability.
I am new to using AI as a system. Help me build one tiny routine from a real task.
My task:
[turn messy notes into a plan / draft an email / research a decision / learn a topic]
My messy input:
[paste non-sensitive notes, or replace private details with placeholders]
My goal:
[what I want back]
My red lines:
Do not send messages, post publicly, spend money, change accounts, delete anything,
make commitments, make final decisions for me, ask for secrets, or continue if my
input contains sensitive/private material that should be replaced with placeholders.
Do not make therapy, counselling, diagnosis, treatment, medical, legal, financial,
tax, crisis, regulated-advice, or guaranteed-outcome claims.
Please give me:
1. a plain-English name for this workflow;
2. the inputs you need next time;
3. a useful first draft or organized output;
4. a checklist I can use to review it;
5. anything risky that needs owner approval;
6. one sentence I should add to my context card for next time.Teach me this like a practical system.
Topic/workflow: [what I want to learn]
Outcome I want: [what I should be able to do]
My current level: [beginner/intermediate/what I already know]
Constraints: [time, tools, budget, platform, risks]
Please:
1. explain the mental model;
2. show the workflow step by step;
3. give 3 examples;
4. quiz me to find gaps;
5. correct my understanding;
6. give me one small practice task;
7. define how I verify whether I did it correctly;
8. suggest how to update my notes/prompts after the attempt;
9. keep risky actions draft-only and flag anything that needs owner approval.
Do not make therapy, counselling, diagnosis, treatment, medical, legal,
financial, tax, crisis, regulated-advice, or guaranteed-outcome claims.I am learning to become an AI developer. Help me build this project in small,
safe steps.
Project idea:
[describe it]
Current level:
[beginner / some coding / comfortable with basics]
Constraints:
[Mac/Windows, tools, time, budget]
Safety rules:
- Do not ask for secrets, passwords, API keys, 2FA codes, private tokens, card
details, customer data, or sensitive records.
- Do not deploy, push public, create accounts, change billing, delete files, send
messages, or change settings without owner approval.
- Start with a plan and file list before code.
- Keep changes small.
- Include tests or a verification checklist.
- Explain every command before asking me to run it.
Please give me:
1. the smallest useful version;
2. files needed;
3. acceptance criteria;
4. owner gates;
5. step-by-step build plan;
6. how to verify PASS/HOLD/FIX.Review this code/diff like a cautious AI developer.
Check:
1. Does it match the spec?
2. Are there hidden account, network, file, deletion, deploy, or public-send actions?
3. Are secrets avoided?
4. Are errors handled?
5. Are tests or evals present?
6. Is the README accurate?
7. What should be PASS, HOLD, or FIX?
Do not approve deployment, public push, spending, account changes, or destructive
commands.Review the last 7 days using only what I provide. Ask up to 5 clarifying questions
if needed. Then produce:
1. what changed;
2. what should update in my profile/context;
3. which goals, assumptions, prompts, or routines are stale and should be pruned;
4. which AI instructions, prompts, or review gates should change;
5. one simple next-week operating rhythm;
6. any risky actions that need owner approval.
Do not make clinical, medical, legal, financial, tax, crisis, or guaranteed-outcome
claims. Keep risky actions draft-only.Before any action, ask:
If no, HOLD.
DWAI shares practical AI and AI-developer-path resources for thinking, drafting, organizing, researching, reviewing, learning, coding, debugging, testing, building small AI apps, and shipping owner-controlled projects. This is not therapy, counselling, diagnosis, ADHD or addiction treatment, medical advice, legal advice, financial advice, tax advice, crisis support, regulated professional advice, or a guarantee of clarity, productivity, income, saved time, business results, jobs, clients, or any personal outcome. AI outputs are drafts. The owner approves risky action.
Use this resource for: The complete free path: safe AI foundations, developer setup, coding basics, AI-assisted coding, first AI API app, RAG/tool-calling basics, tests, deployment checks, and portfolio capstone.
NotebookLM is a third-party Google tool. If you use it, upload only public DWAI downloads or copied public resource URLs. Do not upload private notes, secrets, customer data, account screenshots, or completed workbook pages.
Do not upload completed workbook pages, context cards, customer/private data, private business records, passwords, API keys, 2FA or recovery codes, medical, legal, financial, tax, crisis, or sensitive personal details unless you have intentionally replaced them with placeholders and accept the tool's data terms.