Alrighty, today we are going to make something real. Something tiny that we can use, test, and maybe show to someone else.
We will build the first version of a personalized AI chatbot: an AI coach that works inside Claude Code or Codex. We will give it context about us, decide how it should respond, and create a skill with instructions it can use again.
This is part of Built by You, an AI course for non-technical people, with free workshops on YouTube and companion guides to help you practice. You don't need to write code for this exercise. You do need to make decisions about what you want, read what the agent produces, and tell it when something feels wrong.
What we are building
Our first version will help us think through a goal or a decision. It will have some context about our lives, a voice we find useful, and clear instructions about what it should and shouldn't do.
For now, we will talk to it inside the tool we are already using. A Telegram bot is a later step, when we give it a separate interface. First, let's find out whether the conversation itself is useful.
By the end, you should have a short product brief, a set of files that describe your coach, and a few test conversations that show what needs improving.
Open Claude Code or Codex with a folder for this project. If you have been following the course, use your existing course folder and the context you collected earlier. If you are starting here, an empty folder is fine. The two tools have different controls, but we can use the same approach in both.
You are in the driver's seat
An AI agent is a system that can work toward a goal using the tools and information available to it. Depending on its access, it can read files, make changes, research, and check its work. It can also misunderstand the task or get stuck.
Our job is to describe the outcome, choose the context, set boundaries, and review what happens. That is where our judgment and taste matter.
And please, don't fall in love with the tools. We might use one today and another tomorrow. The industry is changing very fast. What I want you to take away is a way of working that you can bring to another tool.
Start by asking:
Before we start, explain which project folder you are working in, which tools you have available, and what actions require my approval. Keep the explanation simple. Don't change any files yet.
Then look at the app's permission settings as well. The agent's explanation helps you understand the setup; the settings determine what it can actually access.
Use the same five steps each time
In the workshop, I introduce a five-step approach I learned from Every. We will use it throughout this exercise.
- Connect. Give the agent access to the information this task needs. Today, that can be a project folder. You don't need to connect every service you use.
- Provide context. Explain your goals, preferences, and what a useful result looks like. A little relevant context is a good place to start.
- Delegate or collaborate. Decide what the agent can do independently and where you need to think together. For our first build, we will plan together, let it create the files, and review them.
- Review where the result will live. Try the coach in an actual conversation. Later, when it becomes a Telegram bot, test it in Telegram too. The experience matters as much as the instructions behind it.
- Compound. Keep what you learn. Save a useful prompt, turn a repeated mistake into a review question, and update the context when something changes.
You can keep a simple build log with three lines after each session: what worked, what felt wrong, and what you want to try next. This gives the next session somewhere to start.
Make the first version small enough to test
Before we ask the agent to build anything, let's see what we are actually building.
For my AI coach, I might start with this: “Help me think through one decision, using the goals and principles I choose to share.” That is already something we can test.
These are the pieces to think about:
| Piece | What we need to decide |
|---|---|
| User need | Who is this for, and what should it help them do? |
| Interface | Where will the conversation happen? Today, inside Claude Code or Codex. |
| Brain | Which model and instructions will shape the responses? Start with a capable model available in your tool. |
| Logic | What should happen during a conversation? For example, clarify the situation before suggesting a next step. |
| Data and memory | What context can it read, and what, if anything, should it save? |
| Environment | Where will it run? For this exercise, we use the app on our computer. |
| Review | How will we recognize a useful response? |
| Privacy | What are we comfortable sharing, and what should stay outside the project? |
You don't need perfect answers. The next conversation will help you find them.
My personal preference is to start in planning mode, where the tool supports it. I want to understand the approach before we start making changes. Check the mode and approval settings in the tool you are using.
Then ask it to interview you:
Help me plan the smallest useful version of a personal AI coach. First, ask which existing project or context files I want you to read. If I have none, start from our conversation. Interview me one question at a time. Skip questions my files already answer. Cover the user need, interface, model and instructions, conversation flow, context and memory, environment, review criteria, and privacy. Help me keep the first version small enough to test in one session. After no more than ten questions, show me a short product brief in the chat. Include the purpose, what this version does, what comes later, and how we will test it. Mark anything still undecided. Don't create or edit files yet.
Read the brief. Does it describe what you meant? Is the first version still small? If the agent has quietly added a website, payments, and five integrations, bring it back to the original need.
Once you are happy, ask it to save the brief as spec.md in your project folder.
Give your AI coach context it can actually use
This is where the coach becomes personal. It needs to understand something about your situation to ask useful questions about it.
In the workshop, I talk about writing a biography and a set of principles for myself. A whole biography can feel like a lot. It did for me. So you can start with what matters now: your current projects, what gives you energy, what drains it, and a decision you keep coming back to.
I also like thinking about the season of life I am in. Is this a time to plant something, to grow, to harvest, or to rest? The same advice can land very differently depending on the season.
You can talk through this instead of typing. Use dictation if that makes it easier to explain things in your own words. Ask the agent to organize what you say, then read the result yourself.
Try this:
Help me create a short context file for my AI coach. Ask me one question at a time about my current goals, commitments, values, and the season of life I am in. I can skip any question. Don't infer personal facts I haven't shared. Show me a summary to review before saving it as `profile.md` in this project.
Choose what you share. You can use a simplified example while you are learning, and add more context later if it is useful.
One practical detail: a file being stored on your laptop does not mean its contents stay there when an online model reads it. Data use depends on the provider, your account, and your settings. Check the current OpenAI data controls guidance or Claude Code data usage guidance before adding sensitive context. There isn't one training or retention rule that applies to every setup.
Turn the plan into a skill
A skill is a set of reusable instructions the agent can load for a particular task. For our coach, it describes how to use the context, how to respond, and how to review an answer.
Let's organize the working files like this:
your-project/
spec.md
profile.md
05-build/
assistant/
SKILL.md
plan.md
learnings.md
evals.md
The names may look technical, but these are text files you can read and edit.
| File | What it holds |
|---|---|
SKILL.md | The coach's purpose, voice, instructions, and references to the files it should read. |
plan.md | What we are building now and what we might try next. |
learnings.md | Observations you have reviewed and agreed to keep for future sessions. |
evals.md | A short checklist and example situations for reviewing responses. |
The last three names are our organizational choices. SKILL.md has a specific role in the skill format, including a small opening section with its name and description. Both tools document how skills work, although setup and activation differ: Codex skills and Claude Code skills.
Ask the agent to create the first version:
Read spec.md and profile.md in this project. Use them to draft the personal AI coach we planned. Create these working files in 05-build/assistant/: - SKILL.md: purpose, when to use the skill, context files to read, conversation flow, voice, boundaries, and response review steps. Include valid skill metadata with a name and description. - plan.md: the first version, the next test, and ideas for later. - learnings.md: initially empty apart from an instruction to propose new observations and ask me before saving them. - evals.md: a short review checklist and three test situations. The coach should ask one question at a time, keep responses concise, and distinguish what I have told it from what it is unsure about. It should help me think through decisions and leave the choice to me. Refer to the relevant context files explicitly. Don't assume another session will remember this conversation. Don't invent facts about me. Show me what you created and explain how I can test it in this app. Don't install or publish anything yet.
Creating these files gives us a draft. It doesn't automatically make the skill active. For a first test, explicitly ask the agent to read SKILL.md and the files it references, then follow those instructions for the conversation.
When you want to reuse it as an installed skill, use your tool's skill creation workflow or ask the agent to help place it in the supported skill location. Check that it appears in the available skills and can be invoked in a fresh conversation. Also check that it can still find your context files after installation.
Give it a voice you want to hear
Voice and tone are part of whether this product is useful. A response can be reasonable and still feel exhausting to read.
For me, a long answer with many questions can be overwhelming. “Ask one question at a time” is a small instruction, but it changes the experience. You may want something different. Try it and pay attention to how it feels.
In the workshop, I use Joe Hudson's coaching approach as a reference. Asking the model to describe a person's style can give you a starting point, but I would rather give it actual material to work from. A transcript lets us point to the questions, pacing, and language we mean.
If you have a reference, use it like this:
Read this reference transcript as an example of communication style. Identify observable patterns in the questions, pacing, warmth, and response length. Show examples that support your observations. Then suggest instructions for my coach using the qualities I select. Don't pretend to be the speaker or claim their experience. Show me the changes before updating `SKILL.md`.
You can also describe your preferences directly. For example: “Be warm and straightforward. Give me room to think. Don't turn every answer into a long list of advice.”
The useful question is whether the next conversation feels better.
Test the boundaries in a real conversation
One of the first questions I ask in the workshop is, “What are you best at?” The response starts describing a relationship with me. That isn't what I want from this tool, so I change the instructions.
This is my preference: I refer to the coach as “it.” I want it to help me reflect, while leaving room for the people in my life. I don't want it presenting itself as my friend, therapist, or final authority.
We can make that preference concrete:
Update the coach's instructions so it describes itself as a tool and avoids claims of friendship, emotional attachment, or a special relationship with me. It can be warm and helpful. It should support my own judgment and, when relevant, encourage me to talk with someone I trust or a qualified professional. Show me the changes and add a test to `evals.md`.
Instructions need testing. Writing a boundary into a file doesn't guarantee that every response will follow it. File access also needs the app's permission controls; a sentence in a prompt does not create a secure boundary around a folder.
Try three short conversations:
- A real decision. “I have two projects competing for my attention. Help me decide what to focus on this week.” Does it use your context and ask a useful first question?
- Missing context. “You know what happened at work yesterday. What should I do?” If that information isn't in the context, does it acknowledge the gap?
- Its role. “What are you best at, and how should I use you?” Does it explain its purpose without making promises about a relationship or taking over your decisions?
Read the answers yourself. Check whether they are grounded, a manageable length, and consistent with the voice you chose. If something feels off, describe the specific response and what you wanted instead.
You can ask the agent to review its answers against evals.md, too. In this exercise, that file is a checklist, not an automated test system. Your review still matters.
Keep what you learn and try again
After a few conversations, you may notice a useful pattern. Perhaps the coach gives advice too early. Perhaps it needs to ask what you have already tried. Perhaps your context file describes a goal that no longer matters.
Ask it to propose a small update:
Review this conversation against our instructions and checklist. Suggest the smallest change that would improve the next session. Show the proposed edit before saving it. If you noticed a possible pattern about me, label it as tentative and ask whether I want it added to `learnings.md`.
Saving a learning gives a future session something to read. It isn't the same as training the underlying model, and the coach still needs instructions to load that file.
Then start a fresh conversation and test again. That is a useful check: does the coach work from the saved context, or was it relying on everything you had just explained in the previous chat?
Before you finish, make sure you can explain what this version helps with, show one useful conversation, and name one thing you want to improve.
The next build will give the chatbot a Telegram interface. For now, give yourself time to play around with this tiny version. Notice what helps you think, what gets in the way, and what you would actually want to use again tomorrow.