A hands-on 2–3 day program that teaches your teams to direct AI — from the terminal and agentic tools to a structured knowledge base, live builds, and an executive console. Non-technical by design.
Your teams already know their work. This program gives them the tools and the judgement to hand the repetitive, document-heavy, and technical parts to an AI they direct and review — and to walk out having built something real for their own function.
Participants learn to brief, supervise, and review an AI agent — not framework syntax. The skill is the instruction and the check.
Every session ends in an artefact: a knowledge base, a live page, an SOP workbook, a console — using the exact methods behind this deck.
Designed and delivered by Jeremy Fritzhand — who built a full institutional knowledge base, SOP system, and public tools with these methods.
Agentic AI can now read your files, run real commands, and build working software while a person directs and checks it. Work that used to require an engineer — structuring documents, drafting procedures, standing up an internal tool — is now within reach of the person who owns the problem.
File a ticket, join a queue, explain the context, wait weeks for a first version.
Describe the outcome, review each step, and iterate to a working result the same day.
Every function can structure its knowledge, ship internal tools, and report itself — without adding headcount.
| Session | Focus | Teams leave with |
|---|---|---|
| Day 1 · Morning | The 50,000-ft view — terminal, IDE, agentic development, MCP, Claude's models & effort, connecting email & Drive, safety | A clear mental model and their own AI workspace connected to their tools |
| Day 1 · Afternoon | Building a structured, AI-readable knowledge base from the documents you already have | The skeleton of a real knowledge base for one function |
| Day 2 | From setup to shipping — Git & GitHub, deep research, fan-out agents, a live case study, and function SOPs → workbook → console | A deployable build and a repeatable operating method |
| Day 3 · Optional | A hands-on build lab: each function applies the method to its own work, with support | A finished KB + SOP workbook + draft console for their function |
Participants use their own documents and problems — not toy examples — so the output is usable on Monday.
Claude, Gemini, or ChatGPT — the workflow is the same. We teach the method, not one vendor.
Institutional accounts, access scoped to a folder, and a human who reviews before anything is accepted or sent.
Nothing the AI produces is trusted until the person who does the work has checked and corrected it.
We go deep on a single team's workflow so the pattern is proven before it scales.
Teams leave able to repeat this without us — the whole point of the program.
What the terminal is, what an IDE is, what "agentic development" means, how Claude's models and effort settings work, what an MCP is, and how to connect your email and Google Drive — in plain language, for people who have never written code.
The terminal is a plain text window where you type instructions and your computer carries them out. It is Terminal on macOS and Linux, PowerShell on Windows — same idea everywhere: type a command, press enter, something happens.
You will not memorise these. The AI types them for you — this is only so the screen is not a mystery.
$ npm create # start a project
$ npm install # add the tools
$ git init # track your work
You do not sit at the terminal typing commands by hand. An agentic IDE sits on top of it and runs the real commands on your machine for you.
The AI decides which commands to run, runs them, and shows you the result. You watch and approve — you never type them by hand.
An IDE is the workspace where your code and content live and get edited — one window that holds all your project files. An agentic IDE goes further: it can act on that folder itself.
EDITOR vs AGENTIC IDE
A plain editor is a place you type into. An agentic IDE — Claude Code, or VS Code with an agent — is a place you give instructions to, and it does the typing.
AN AGENTIC IDE CAN
You direct, the AI executes, and you review. This is human-in-the-loop: you approve every step and check the changes — you never blindly accept.
There are a handful of moving parts, but they fit together in a simple picture. You do not need all of them — and the ones you pick are interchangeable.
Each major model comes paired with an agentic IDE. Any one of these will do the job. Choose the one your teams already use.
The Claude model, driving Anthropic's agentic coding tool.
The Gemini model, driving Google's agentic IDE.
The GPT model, driving OpenAI's agentic coding tool.
The workflow is identical whichever you choose. Learn it once; the vendor is a detail.
First-pass documents and emails, ready to refine.
Long email threads and PDFs, down to the point.
Small internal tools and sites for your functions.
Scattered files structured into a knowledge base.
First drafts your teams edit, not start from blank.
Fast analysis and comparison across sources.
Speed is the point, but so is accountability. The AI produces the draft; a person owns the outcome.
Review every change before you accept it. Never let output go out unread. Keep a named human accountable for anything that leaves your desk — a document, a decision, a line of code.
Claude comes in three tiers. They share the same skills; they differ in how deeply they reason and how fast they respond. Match the tier to the task in front of you.
The most capable tier. Reach for it on hard, ambiguous, high-stakes work — strategy, thorny analysis, careful review.
Strong reasoning at good speed. The right default for most everyday work — drafting, research, summaries.
Quick and economical. Use it for simple, high-volume tasks — fast lookups, sorting, short replies.
Beyond the model, you set the effort — how much the AI thinks before it answers. It is like a colleague: sometimes you say "think it through", sometimes "just answer".
More thinking costs a little more time. Spend it where the decision actually matters.
WHERE TO SPEND IT
MCP — the Model Context Protocol — is an open standard that lets your AI securely connect to your own tools and data: email, Drive, GitHub, databases, calendars.
Think of MCP as a universal adapter between the AI and your systems — one standard, many connectors, no custom wiring per tool.
Connect Gmail as a connector and the AI can search, summarise, and draft from your inbox — while you stay in control of what actually goes out.
The AI acts only within the access you grant — no more, no less.
Google Drive works the same way. The AI can read your folders, pull the facts you need, and write new files back — turning static documents into a knowledge base you can question.
A connected Drive is what makes a knowledge base live, not static. This sets up the afternoon.
Before writing anything new, point the AI at the systems your team already fills every day. Auditing them turns scattered records into a structured, searchable knowledge base.
Connect read-only first, with permission. The AI extracts and structures; a person reviews what enters the knowledge base.
The moment an agent can read your files, your inbox, and your Drive, good habits stop being optional. Five we set from day one.
Point the agent at one folder and grant only the access it needs — never the whole drive by default.
Keep permission prompts on for commands, sends, and deletes. Read what it is about to do before you say yes.
Keep personal, legal, and regulated data out of AI-readable folders until policy clears it. Use institutional accounts.
Treat every draft as wrong until checked. The AI sounds confident even when it is not — a human signs off.
Version everything with Git and back up before big changes, so any step can be undone.
The agent does the work; a named person owns the result. That never transfers.
Take the documents a function already has — scattered across folders, inboxes, and drives — and turn them into a tidy, AI-readable knowledge base: the source of truth that every deck, report, and SOP is generated from.
It is your work, organised — a tidy folder an AI can read, plus a memory of how your function thinks. You are not building an app. You are putting what you already have in order.
You do not. You point an AI at your files in plain English, and it does the moving, sorting, and writing for you.
There is nothing to break. It is folders and plain text — a copy of your own documents. You can always start again.
A short, standard kit an AI can drive on your behalf.
The documents, sheets, and notes your function already owns.
A clean, named structure so every file has an obvious home.
One plain-language file per folder, plus a single map of the whole thing.
Your colours, fonts, and voice — written down once and reused.
A record of how your function decides: its rules and preferences.
The AI builds the structure; people run it. Your job is direction and judgement — not typing.
Start with one function. A base with gaps and [to-verify] tags beats a perfect document that never ships.
It is the source of truth everything else is generated from — one tidy base, many outputs.
Presentations already in your colours, fonts, and voice.
Long-form documents that read as finished, not draft.
Simple pages that walk a reader through one topic.
Sheets and standard-procedure books your team runs on.
One report pulled together from many scattered sources.
Emails, briefs, and notes written from what you already know.
Be honest about the effort. A skeleton takes an hour; a base your team actually trusts takes months of real use — after that, it needs almost no upkeep.
The method costs almost nothing in software; the investment is people's time and a few paid AI seats.
A finished base is not a filing cabinet — it is queryable. Ask it in plain language and it pulls the answer from your own records: contacts, org structure, history, numbers.
Ask it things like
Real example: a full institutional knowledge base holds the team, partners, portfolio, finances, and history — and answers all of the above from the repository itself.
> Pull every partner contact from
08-partnerships into a table:
name, org, email, last touch.
> Draft the team org chart from
01-organization/team-roles.md.
The technical foundations — Node, Git, GitHub, a host — then the advanced moves: deep research, fanning out agents, a real case study built this way, and how each function turns interviews into SOPs, a workbook, and an executive console.
A short install session gets everyone on the same footing.
The local toolchain that runs projects on your computer.
Version history — a save-game for your work.
Stores your repo online and connects it to deploy.
Free hosting, plus a custom domain of your own.
Claude Code or VS Code — where the AI works alongside you.
Every tool has a free tier, and the AI walks you through each install step — you do not need to know how any of it works.
You can run the AI coding agent on your own machine or entirely in the browser. Pick by comfort level, not by rule.
You push your work to GitHub. The host builds it and serves it worldwide — on a custom domain, over HTTPS, automatically. No servers to manage.
Source stays in GitHub; the built site is served by the host. One push, and the change is live in seconds — no servers to manage.
Hosting shows your site. It does not remember anything. For apps that store users, orders, or records, you add a database — Firebase or Supabase.
Stores users, orders, records, and settings — and lets an app create, read, update, and delete them.
Hosting shows your site and runs functions. The data lives in a separate service alongside it.
Firebase: a NoSQL store with realtime sync. Supabase: a SQL (PostgreSQL) database. Both add auth and storage.
The AI runs many searches, reads dozens of sources, and returns one cited synthesis — for market, regulatory, competitive, and landscape questions.
Always open the citations and check them. Treat the synthesis as a strong first draft, not a verdict.
GOOD USES
The advanced move: run many AI agents in parallel. Each reads one part of a problem. Others adversarially verify every finding before it is trusted.
Used for exhaustive research, audits, and migrations too big for one context. The India schemes guide was built this way — one agent extracts, another independently re-checks every number.
A skill is a small folder of instructions — plus any templates or scripts — that teaches Claude how you do a specific task. Save it once, and Claude follows it every time, the same way.
WHAT A SKILL IS
HOW TO CREATE ONE
You don't have to write every skill yourself. gstack is an open-source pack of 23+ skills for Claude Code that turns it into a virtual engineering team — plan, build, review, test, and ship, each a command away.
WHAT YOU GET
INSTALL IN 30 SECONDS
git clone --depth 1 \
https://github.com/garrytan/gstack \
~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup
github.com/garrytan/gstack — then add a gstack section to your project's CLAUDE.md.
In June 2026 the Government of India published the "Playbook of Government Schemes and Initiatives for Startups" — 107 pages of dense policy. The content is useful. The format makes it impossible to navigate.
BUILT IN, NOT BOLTED ON
Fan-out plus adversarial verification in practice: many pages built in parallel, each one checked by an agent that did not write it.
The India map is not a one-off. The same pipeline takes any structured set of documents and produces the same kind of site — searchable, accessible, and free to host.
WHAT YOUR TEAMS COULD REBUILD
Live at fritzhand.github.io/startup-india-guide.
Each team turns what it already does into onboarding docs and SOPs. Knowledge survives staff transitions, and new joiners get productive fast.
This is a capability your functions build for themselves, not a compliance box they tick. The people who do the work own the record of how it is done.
AI DRAFTS · OPERATORS VALIDATE
Nothing is trusted until the person who does the work has corrected it.
Record the call, and the AI does the rest: a clean transcript, structured minutes, and a tracked list of action items with owners — filed straight into the knowledge base.
Nothing is lost between meetings. Minutes feed the SOPs; action items feed the console — so the record and the follow-through live in one place.
CAPTURED FROM EACH PERSON
Definition
Process Owner
Approver
Frequency
Trigger
Process Flow (numbered)
Step | Action | Resp. | Approver
Output / record
Related documentsREPEAT UNTIL CORRECT
The document is the data — you correct the source, not the polished output.
One owner, one page, fixed shape, every month.
FROM A REAL FACILITY BUILD — ILLUSTRATIVE FOR ONDC
Quarterly, each function's console rolls up so leadership sees the whole organisation in one shape.
Documents before dashboards. A leadership dashboard is only as alive as the workspaces that feed it.
Each participant
Each function
With the optional Day 3 build lab, each function leaves with a finished v1 knowledge base, SOP workbook, and draft console — not just the method.
A 2-day core, plus an optional Day 3 hands-on build lab per function.
Sized so every participant is at a keyboard and gets attention. Multiple cohorts by function.
Delivered on-site or live online, adapted to ONDC's context and examples.
A paid AI subscription per participant and admin rights to install a few free tools.
Each team gathers its documents beforehand — the raw input for the knowledge base.
Optional post-workshop clinics while teams put the method into practice.
I'd welcome a conversation about tailoring this to ONDC's functions and calendar. The next step is a short scoping call to choose the exemplar function and set the dates.