Program · Individuals

Building Personal AI Assistants (No-Code)

Go beyond “chatting with AI” and design a handful of small assistants that actually do jobs for you — drafting, organizing, summarizing, and nudging you at the right time. All with no code, using tools like ChatGPT and Google Gemini.

You'll learn how to define one clear job per assistant, write instructions it can really follow, safely connect it to your own notes and docs, and keep everything maintainable as your work changes.

Program overview · Audio

A short overview of how this program helps you design, build, and use personal AI assistants without writing a line of code.

What you’ll be able to do after this program

Less generic chat, more small assistants with real jobs and clear boundaries.

  • • Design personal AI assistants around specific jobs, not vague superpowers.
  • • Configure assistants in tools like ChatGPT and Gemini using clear instructions and examples.
  • • Safely connect assistants to your own notes, docs, and reference material.
  • • Run lightweight “reviews” on your assistants to keep them useful over time.
  • • Build a small “assistant roster” that fits your work instead of a junk drawer of bots.

Who this is for

  • • People who already use AI a bit for daily tasks
  • • Knowledge workers, operators, and managers
  • • Creators, freelancers, or solo builders wanting “micro teammates”

What you’ll work on

  • • 2–3 assistants connected to your real work
  • • Clear assistant briefs and instructions
  • • A simple system to review and improve them

Curriculum at a glance

Four modules to design, configure, connect, and maintain your personal assistants.

Module 1

Designing assistant jobs & boundaries

  • Picking one clear job per assistant
  • Defining inputs, outputs, and “done” for each job
  • Setting boundaries so assistants don’t overreach

Module 2

Configuring assistants in ChatGPT & Gemini

  • Writing system instructions your assistant can follow
  • Using examples and starter conversations
  • Adding tools / actions without making things brittle

Module 3

Connecting assistants to your notes & docs

  • When (and when not) to connect your own data
  • Lightweight knowledge bases from your existing tools
  • Keeping content fresh without constant manual updates

Module 4

Operating, reviewing & improving assistants

  • Collecting simple feedback from your own usage
  • Versioning instructions without losing the plot
  • Knowing when to retire, replace, or split an assistant

1. Designing assistant jobs & boundaries

Before you build anything, decide what each assistant is actually responsible for.

We start by treating assistants like tiny roles on your team. Each one gets a single job, with clear inputs, outputs, and "this is not my job" boundaries.

  • • Turning vague wishes into specific assistant jobs
  • • Defining inputs, outputs, and “done” conditions
  • • Avoiding “do everything” assistants that fail you
  • • Choosing 2–3 assistants that really matter

Exercise: assistant job descriptions

You'll write short job descriptions for your first assistants, including:

  • • The job they do and for whom (you, a client, a team)
  • • Inputs they need to do it well
  • • What a good output looks like
  • • Things they explicitly shouldn’t do

2. Configuring assistants in ChatGPT & Gemini

Turn those job descriptions into real, working assistants — no code required.

Next, we translate your job descriptions into system instructions, examples, and starter conversations inside the tools you already have.

  • • Writing clear, constrained system instructions
  • • Using examples to tighten behavior
  • • Designing “intake questions” your assistant asks you
  • • When (and when not) to add tools / actions

Your first configured assistants

You'll configure 1–2 assistants in ChatGPT, Gemini, or similar that:

  • • Introduce themselves and their job clearly
  • • Ask for the right inputs up front
  • • Produce repeatable, predictable outputs

3. Connecting assistants to your notes & docs

Give your assistants access to the right information — without creating a privacy mess.

Then we connect assistants to the information they need: your own notes, docs, and reference material — starting small and keeping safety in mind.

  • • When connecting data actually helps vs. overcomplicates
  • • Creating small “knowledge packets” for each assistant
  • • Using existing tools (Notion, Drive, Docs) as sources
  • • Keeping things updated without constant manual work

Your assistant knowledge kits

We'll define and set up small knowledge kits for each assistant, such as:

  • • A folder of reference docs or templates
  • • A short “how we do things here” guide
  • • A simple process for adding or removing docs

4. Operating, reviewing & improving assistants

Treat your assistants like evolving teammates, not one-off toys.

Finally, we focus on how you'll use, review, and improve your assistants over time — without turning it into a full-time job.

  • • Light-weight feedback and “incident” notes
  • • Versioning instructions so you can roll back
  • • Splitting one overloaded assistant into two
  • • Knowing when to retire or replace an assistant

Assistant roster & review cadence

You'll leave with a small “assistant roster” document that tracks:

  • • Each assistant’s job and owner (you)
  • • Where it lives and what data it uses
  • • A simple monthly or quarterly review checklist

Format & logistics

A practical, intermediate-level program for people already using AI day-to-day.

Schedule

  • • 3–4 weeks total
  • • Weekly live sessions (60–75 minutes)
  • • Optional office hours for troubleshooting

Group size

  • • Individuals or groups of 3–12
  • • Great for “AI champions” inside a team
  • • Intermediate: prior AI basics recommended

What you leave with

  • • 2–3 configured personal assistants you actually use
  • • Clear job descriptions and knowledge kits for each
  • • A simple playbook for reviewing and improving them

FAQ: Building Personal AI Assistants (No-Code)

Questions people usually ask before building their own assistants.

Do I need technical or coding experience?

No. This program is explicitly no-code. If you can use tools like ChatGPT, Google Docs, and a browser, you're set. We focus on design, configuration, and habits — not code or complex integrations.

How is this different from the Foundations or Productivity programs?

Foundations teaches core prompting and safety. The Productivity program focuses on your personal workflows. This program is about going one level up: turning repeatable tasks into small, named assistants with clear jobs and setups you can reuse.

Will we connect to company systems or just personal tools?

It depends on your situation and policies. Many people start with personal or non-sensitive data (notes, templates, public resources) and then expand carefully. We'll talk about what's safe and appropriate for your context.

Can I reuse this approach to build assistants for my team?

Yes. The same patterns — clear jobs, boundaries, instructions, data, and review — apply to team-facing assistants too. This program is a good “lab” before building more formal, org-wide assistants.

Ready to build your own personal AI assistants?

This program helps you move from generic AI chat to a small roster of assistants that quietly support your real work, week after week.

Talk to us about this programView all individual programs

If you’d like to run this as a private cohort for a small team or group of “AI champions,” mention that in your note and we'll share options.