Building your AI economist toolkit

By now you can prompt well, ground a model on documents, and reason about agents. But if every session starts by re-explaining who you are, the style you write in, and where the numbers live, you are still doing craft work by hand. This module assembles those skills into a workspace — the difference between owning a set of good tools and owning a workshop. It has four layers, built in order: an assistant tuned to you, so your context is assumed rather than repeated; saved templates and a prompt library, so your best instructions are reused rather than remembered; a grounded knowledge base, so answers are checkable against your own documents; and light automation on top, so routine chains run themselves — up to the point a human must sign off. Get the lower layers right and the automation is safe; automate on top of ad-hoc prompting and you simply scale your mistakes.

Layer 1 — Tune the assistant to you

Every major assistant now carries standing context between chats. ChatGPT has custom instructions plus memory; Claude has profile preferences and per-project custom instructions; Gemini has saved info and personalisation. Set these once and every future answer starts from your reality instead of a blank slate. For an economist or policy analyst, encode:

• Who you are and who you serve: 'I am a policy analyst at a Nairobi think tank advising county treasuries and development partners.'
• House conventions: British English, figures in KES with the source named, dates as DD Month YYYY, cite KNBS, CBK, National Treasury, or World Bank data explicitly.
• Default output shape: 'Unless I say otherwise, structure briefs as Issue, Evidence, Options, Recommendation.'
• Standing anti-hallucination rule: 'Never invent a figure, citation, or quote. If you are unsure, say so and mark it for me to verify.'
• What to avoid: no hype, no filler adjectives, no fabricated precision (do not write 7.31% when the source says about 7%).

Layer 2 — Build a reusable, grounded assistant

• Custom GPTs (ChatGPT, paid tiers): a saved version of ChatGPT with standing instructions, uploaded knowledge files it retrieves from, and optional Actions that call external APIs. Keep it private or share by link.
• Claude Projects (Claude, paid tiers): a Project bundles a shared knowledge base — documents you upload, up to a 200K-token window — with custom instructions that apply to every chat inside it. Shareable with teammates on Team and Enterprise plans.
• Gemini Gems (Gemini): a customised Gemini you set up once with a name, standing instructions, and up to ten knowledge files (or a linked NotebookLM notebook), which it refers to in every chat.

None of these three retrains the underlying model; each is the same idea in different clothes — a named, reusable assistant that carries its own knowledge base, built by configuration rather than fine-tuning. Concretely, build a 'Policy-Brief Drafter': give it your house-style instructions and load its knowledge base with your last twenty briefs, your style guide, and the current KNBS release. When you upload those files, the tool chunks, embeds, and retrieves them at answer time and cites the passage each claim came from — the managed, no-code form of the retrieval-augmented generation you met in the RAG module. That is what makes the assistant checkable rather than merely plausible: it drafts in your voice and shows you where each figure came from. Grounding narrows hallucination; it does not abolish it — the assistant can still retrieve the wrong passage or reach past its sources — so the citation is there for you to verify, not to trust blindly.

Layer 3 — Version your templates and build a prompt library

A prompt that reliably works is an asset, so treat it like code: give it a name, a version number, and a changelog, and keep it in a canonical store (a repository, a Notion page, a shared doc). Structure each template with the six-part anatomy this course uses — it extends the five-block structure from the prompt-engineering module by splitting Data out of Context (the specific inputs the model may use) and making Output an explicit spec rather than a vague 'format': Role, Context, Data, Task, Constraints, Output. Placeholders in {CURLY_BRACES} mark what changes between runs. Here is a reusable literature-review-to-brief template you can copy:

# policy-brief-drafter.v3  (last verified 2026-07-14, model: Claude / GPT)

Role: You are a senior policy analyst at a Nairobi economic-policy think tank. You write in British English and quote figures in KES with the source named.

Context: We advise {AUDIENCE} on {POLICY_AREA}. Our house brief is two pages: Issue, Evidence, Options, Recommendation. We never present a figure without a source.

Data: Draft ONLY from the material between the <sources> tags. Do not use outside knowledge for any number, date, or quotation.
<sources>
{PASTED_SOURCES_OR_ATTACHED_FILES}
</sources>

Task: Draft a policy brief answering: {SPECIFIC_QUESTION}. Follow the house structure.

Constraints: Every quantitative claim must cite its source and page or line from <sources>. If the sources do not support a claim, write '[not in sources]' — do not estimate. Name the two weakest points in the evidence. Keep to 700-900 words.

Output: Markdown with headings Issue / Evidence / Options / Recommendation, then a 'Sources' list, then a 'Verification checklist' listing every figure with its source, for the human reviewer to tick before the brief leaves the building.

• Name by task and version: policy-brief-drafter.v3, mpc-extract.v2, chart-spec.v1 — so you always know which prompt ran.
• Organise into folders by job: research, data-analysis, writing, presentation. Most of your AI use is a handful of repeated tasks.
• Attach metadata to each entry: which model it was tuned for and the date it was last verified against a known-good example.
• Keep a fixed placeholder convention ({CURLY_BRACES}) so a template is obviously a template and nothing is left unfilled.
• Prune ruthlessly: keep the versions that win on your test examples, archive the rest, and record in the changelog why a version changed.

Layer 4 — Automate the workflow, not the judgement

Two things are worth automating. First, chaining: the output of one step becomes the input of the next — a research summary feeds the data-analysis prompt, whose findings feed the drafting template, whose brief feeds the slide generator. Second, light automation of the routine trigger: a no-code platform such as Zapier or Make (both now offer steps that call an LLM) can fire on a new file and run your template, or a scheduled script (cron) can pull a document on a timer. The right pattern queues a draft for a person — it never publishes. For example, a Monday job that fetches the latest CBK MPC statement, runs your extraction template, and drops a draft in your inbox for review:

# Weekly: draft a CBK MPC summary for human review — never auto-send.
# crontab:  0 8 * * MON  /home/analyst/mpc/draft.sh

curl -s "$CBK_MPC_LATEST_URL" -o statement.txt
python run_template.py \
  --template prompt-library/writing/mpc-extract.v2.txt \
  --input statement.txt \
  --out draft.md

# Route to a person, not to the mailing list:
notify_reviewer draft.md   # a human verifies every figure, then decides whether to send

The AI Economist Workspace: four assistants that hand off

Assemble the layers into four specialised assistants, each a configured GPT, Project, or Gem with its own instructions, template, and grounded knowledge base — and each with a human checkpoint before it hands to the next. They form a pipeline: research feeds analysis, analysis feeds drafting, drafting feeds the deck. The prompt library is the shared toolbox all four draw from.

• Research assistant — scans literature and background, synthesises sources, and returns a cited briefing. Built on a corpus you trust (past reports, KNBS and CBK releases, World Bank data) in NotebookLM or a Project. Checkpoint: you confirm every source exists and says what the summary claims before it moves on.
• Data-analysis assistant — cleans, explores, and analyses figures and writes the analysis code (Code Interpreter, Excel Copilot, or Claude with your data files attached). Grounded on the actual dataset, never the model's memory of it. Checkpoint: you re-run or spot-check the numbers and inspect the code before any figure is quoted.
• Policy-writing assistant — turns verified findings into a house-style brief or memo. This is your Policy-Brief Drafter, grounded on past briefs and the style guide, running the versioned template above. Checkpoint: you edit for voice and tick the verification checklist, figure by figure.
• Presentation assistant — converts the finished brief into talking points, a slide outline, and chart specifications. Grounded on the brief itself plus a deck template. Checkpoint: you confirm each slide's claim traces back to the verified brief, not to anything the model added.