AI-Native Development — Chapter-by-Chapter Python Practicals (Chapters 1–20)

Format for each chapter

• Concept summary (1–2 lines)
• Learning objectives (bullets)
• Python Practical(s) (copy-paste runnable snippets; replace YOUR_API_KEY)
• Mini project / exercise (what to build)
• Tests & success criteria (how to verify)

---

Chapter 1 — Welcome to the AI-Native Era

Concept summary: AI is the new compute layer — give instructions and AI executes.

Learning objectives

• Understand system/user roles and basic LLM usage.
• Make simple function calls to an LLM.

Python Practical — Basic chat + calculator

from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role":"system","content":"You are a helpful math engine."},
        {"role":"user","content":"Calculate 143 * 27 and show steps in one line."}
    ]
)
print(resp.choices[0].message["content"])

Mini project: CLI "Task Executor" that accepts 3 user instructions and prints results.

Tests & success criteria: All tasks return plausible, correct outputs (e.g., math matches local calc).

---

Chapter 2 — Intelligence as a Tool

Concept summary: Treat LLMs as a callable service (IaaS). Focus on delegation design.

Learning objectives

• Build a planner-executor loop.
• Use role/system prompts for controlled behavior.

Python Practical — Planner -> Executor -> Verifier

from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")
# Planner
planner = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"system","content":"You are a planner."},
              {"role":"user","content":"Create a 3-step study plan for 7 days for AI-Native book."}]
)
plan = planner.choices[0].message["content"]
# Executor
exec_resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"system","content":"You are an executor."},
              {"role":"user","content": f"Execute step 1 from this plan:\n{plan}"}]
)
print("PLAN:\n", plan)
print("EXECUTION:\n", exec_resp.choices[0].message["content"])

Mini project: Build a planner.py that accepts a task and returns a 3-step plan and executes step 1.

Tests: The planner must produce ordered actionable steps; executor must output a concrete result for step 1.

---

Chapter 3 — Agents Are Developers

Concept summary: Design agents (goal + tools + memory + planner). Create role-based agents.

Learning objectives

• Build a tool-enabled agent that calls local Python functions.
• Implement function-calling pattern.

Python Practical — Function calling

from openai import OpenAI
import json
client = OpenAI(api_key="YOUR_API_KEY")

def greet(name):
    return f"Hello {name}, welcome to AI-native development!"

functions = [{
    "name":"greet",
    "description":"Greet the user by name",
    "parameters":{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
}]

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"system","content":"You call functions when asked."},
              {"role":"user","content":"Say hello to Zyan."}],
    functions=functions,
    function_call="auto"
)
msg = resp.choices[0].message
if msg.get("function_call"):
    fn_name = msg["function_call"]["name"]
    args = json.loads(msg["function_call"]["arguments"])
    if fn_name == "greet":
        print(greet(**args))

Mini project: Create a small tools.py (todo add/list, calc) and let the agent pick which tool to call.

Tests: The agent should correctly parse and call local tools based on the user request.

---

Chapter 4 — Prompt Engineering as a Discipline

Concept summary: Prompts are architecture — system + user + example flows.

Learning objectives

• Write systematic prompts (system role, constraints, examples).
• Use few-shot examples for consistent behavior.

Python Practical — Prompt template utility

PROMPT_TEMPLATE = '''System: You are a concise assistant.
Constraints: Answer in <=50 words.
Example Q: How to learn fast?\nA: Build projects daily.\n
User: {question}
'''

from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")
q = "Give a 2-step plan to revise the AI-Native book in 7 days."
resp = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role":"user","content":PROMPT_TEMPLATE.format(question=q)}])
print(resp.choices[0].message["content"])

Mini project: Build a prompt_builder.py that takes role, constraints, examples and returns the final prompt.

Tests: Different constraints change output length/style predictably.

---

Chapter 5 — Memory & RAG (Long-term Context)

Concept summary: Use embeddings + vector DB for recall; RAG grounds LLMs.

Learning objectives

• Compute embeddings and store them with text.
• Retrieve top-k relevant docs and use them in prompts.

Python Practical — Simple in-memory embeddings + retrieval

import numpy as np
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")

def embed(text):
    r = client.embeddings.create(model="text-embedding-3-small", input=text)
    return np.array(r.data[0].embedding)

memory = []

def store(text):
    memory.append({"text":text, "emb": embed(text)})

def retrieve(query, k=3):
    qv = embed(query)
    sims = []
    for i,item in enumerate(memory):
        sim = float(np.dot(qv, item['emb'])/(np.linalg.norm(qv)*np.linalg.norm(item['emb'])))
        sims.append((sim, item['text']))
    sims.sort(reverse=True)
    return [t for _,t in sims[:k]]

# usage
store("Zyan prepares for December hackathon.")
store("Zyan likes Python and Next.js.")
print(retrieve("What does Zyan like?"))

Mini project: Persist embeddings to disk (JSON+binary) and query them.

Tests: Retrieval returns semantically relevant docs for test queries.

---

Chapter 6 — Tools & Action (Real-world Effects)

Concept summary: Tools allow LLMs to act on the world (APIs, FS, DB, shell).

Learning objectives

• Implement safe wrappers for tools (auth, previews).
• Log tool calls and outputs.

Python Practical — Safe tool wrapper (mock)

import json

def safe_call_tool(name, args):
    # Example safety: block destructive commands
    destructive = ['delete_all_files', 'format_disk']
    if name in destructive:
        return "TOOL BLOCKED: destructive"
    # Mock tool execution
    return f"Executed {name} with {json.dumps(args)}"

print(safe_call_tool('todo_add', {'task':'Finish Chapter 2'}))

Mini project: Build tools.py with 4 tools (calc, todo add/list, read_file, mock_http_get) and integrate with function-calling.

Tests: Tools must enforce safety checks and produce logs (JSONL).

---

Chapter 7 — Multi-Agent Systems

Concept summary: Break concerns across specialized agents to scale complexity.

Learning objectives

• Create orchestrator and 2 agents (search & executor).
• Build message passing between agents.

Python Practical — Very small orchestrator

# Pseudocode style simplified orchestrator
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")

def search_agent(query):
    return f"Search results for {query} (mock)"

def exec_agent(instruction):
    return f"Executed: {instruction}"

# Orchestrator
query = "Find AI-native hackathon project ideas"
results = search_agent(query)
final = exec_agent("Pick top idea and make 3-step plan.")
print(results)
print(final)

Mini project: Implement 3 agents (plan, search, execute) with a simple JSON-based message bus (file or in-memory queue).

Tests: Orchestrator must show message logs and final aggregated result.

---

Chapter 8 — Evaluation, Verification & Safety

Concept summary: Always verify claims; add human-in-loop for critical tasks.

Learning objectives

• Build a verifier step to check outputs against sources.
• Implement simple uncertainty handling.

Python Practical — Verifier pattern

from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")

answer = "The capital of France is Paris."
verification_prompt = f"Verify: '{answer}' Give sources or say 'I don't know'."
ver = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role":"user","content":verification_prompt}])
print(ver.choices[0].message['content'])

Mini project: Add a verification layer that marks answers as CONFIRMED / SUSPECT and posts SUSPECT items for human review.

Tests: Known factual QAs should return CONFIRMED; made-up facts should return SUSPECT or 'I don't know.'

---

Chapter 9 — Scaling & Cloud Deployment

Concept summary: Deploy agents as cloud functions or serverless workflows.

Learning objectives

• Containerize a simple agent and prepare requirements.txt.
• Use environment variables for API keys.

Python Practical — Dockerfile snippet & run

# Dockerfile (example)
# FROM python:3.11-slim
# WORKDIR /app
# COPY . /app
# RUN pip install -r requirements.txt
# ENV OPENAI_API_KEY=""
# CMD ["python","agent.py"]

Mini project: Dockerize your agent.py and run locally; measure latency and memory.

Tests: Container starts and agent responds to a sample request.

---

Chapter 10 — Observability & Logging

Concept summary: Logs, traces, and metrics are critical to debug and improve agents.

Learning objectives

• Log inputs, plans, tool calls, outputs to JSONL.
• Track latency and token usage (approx).

Python Practical — JSONL logger

import time, json

def log_event(path, record):
    record['ts'] = time.time()
    with open(path, 'a') as f:
        f.write(json.dumps(record)+"\n")

log_event('logs.jsonl', {'event':'plan','plan':'step1...','tokens':120})

Mini project: Integrate logging into your agent and produce a short dashboard (CLI summary) of last 10 events.

Tests: Logs contain consistent records for each request and tool call.

---

Chapter 11 — Human-in-the-Loop & UX

Concept summary: Design interactions where user confirmations are required for sensitive steps.

Learning objectives

• Build confirmable actions.
• Design UX flows that show context before commit.

Python Practical — Confirmation wrapper

def confirm_and_execute(action_desc, fn, *args, confirm=True):
    print("Action:", action_desc)
    if confirm:
        ok = input("Type YES to proceed: ")
        if ok.strip().upper() != 'YES':
            return 'CANCELLED'
    return fn(*args)

# example
print(confirm_and_execute('Delete account', lambda: 'deleted', confirm=False))

Mini project: Add confirmation flow to any destructive tool (e.g., delete todo).

Tests: Actions with confirm=True must stop until user types YES.

---

Chapter 12 — Data & Privacy

Concept summary: Handle PII with care; design redaction & minimization.

Learning objectives

• Implement data redaction before sending to LLM.
• Store only needed vectors; encrypt or obfuscate sensitive fields.

Python Practical — Simple redaction

import re

def redact(text):
    text = re.sub(r"\b\d{10,}\b", "[REDACTED]", text)  # naive phone
    text = re.sub(r"\b\S+@\S+\b", "[REDACTED]", text)  # naive email
    return text

print(redact("Call me at 03123456789 or email z@x.com"))

Mini project: Implement a middleware that redacts PII before logging or sending to LLM.

Tests: PII is replaced in logs and outgoing prompts.

---

Chapter 13 — Cost & Performance Optimization

Concept summary: Balance quality vs token cost & latency; caching and chunking strategies.

Learning objectives

• Cache embeddings and RAG results.
• Use smaller models for lightweight tasks.

Python Practical — Simple cache for embeddings

import hashlib, json

def cache_key(text):
    return hashlib.sha256(text