DEV Community: Debbie O'Brien

Getting Started with Claude Code: A Guide to Slash Commands and Tips

Debbie O'Brien — Tue, 31 Mar 2026 21:06:39 +0000

When you first open Claude Code, it's not immediately obvious what commands are available to you. I spent some time today exploring the slash commands and keyboard shortcuts thanks to Matt Pocock's Claude Code for Real Engineers course, and found them genuinely useful for day-to-day work. Here's a quick rundown of what each one does and when you might reach for it.

Slash Commands

`/intro` - Setting Up Your Project Instructions

/intro creates a claude.md file where you can define instructions for how Claude should behave in your project. If you're working in a team or want consistent responses across sessions, this is a good place to start.

`/terminal-setup` - Fixing Multi-Line Input

By default, hitting Enter sends your message immediately, which can be frustrating when you're trying to write something longer. /terminal-setup configures your terminal so that Option + Enter (or Alt + Enter on Windows) gives you a new line instead.

One thing to note: you'll need to restart your terminal app after running this for the changes to take effect.

`/model` - Changing the Default Model

If you want to switch which model Claude Code uses, /model lets you do that. Straightforward, but easy to miss if you don't know it's there.

`/usage` - Checking Your Subscription

/usage shows your current usage for your subscription plan. Handy for keeping track of where you are without having to leave the terminal.

`/context` - Understanding What's in Your Context Window

This one I found particularly useful. /context gives you a breakdown of what's currently loaded in your conversation, with estimated usage by category:

System prompts
System tools
Skills
Messages
Free space

┌─────────────────────────────────────────────────────────────┐
│  /context                                                   │
│  └─ Context Usage                                           │
│                                                             │
│  claude-opus-4-6 · 15k/1000k tokens (1%)                   │
│                                                             │
│  Estimated usage by category                                │
│  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   │
│  ● System prompt:      5.6k tokens  (0.6%)                  │
│  ● System tools:       8.3k tokens  (0.8%)                  │
│  ○ Skills:              715 tokens  (0.1%)                   │
│  ○ Messages:             58 tokens  (0.0%)                   │
│  □ Free space:         952k tokens  (95.2%)                  │
│  ■ Autocompact buffer:  33k tokens  (3.3%)                   │
│                                                             │
│  [████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 1%  │
│   ^^^^                                                      │
│   used                              free space              │
└─────────────────────────────────────────────────────────────┘

It also tells you when autocompaction will happen, that's when Claude automatically trims older context because the token limit is running low. If you've ever wondered why Claude seems to "forget" something from earlier in a long session, this command helps explain what's going on.

`/clear` - Starting Fresh

/clear wipes your chat history and context window. It's essentially the same as closing and starting a new Claude session. Useful when you're switching to a completely different task and don't need the previous context hanging around.

`/ide` - Connect to Your IDE

There's a Claude Code extension for VS Code, and you can connect to it by running /ide. Once connected, things like git diffs will open in VS Code instead of displaying in the terminal. If you're reviewing changes regularly this is a much better experience, you get proper syntax highlighting and the familiar side-by-side diff view rather than trying to read through diffs in the terminal.

`/resume` - Browse Previous Sessions

Type /resume and use the up and down arrow keys to browse through your previous sessions. There's also a search box so you can find a specific session across all sessions in the repo.

Tips

Interrupting Claude with Escape

Press Escape at any time to interrupt Claude while it's generating a response. If you want it to continue from where it left off, just type "go." Press Escape again if you want to stop it for good.

This is helpful when you realise partway through that you need to rephrase your question or Claude is heading in the wrong direction.

Rewind with Escape + Escape

Press Escape twice to enter rewind mode. This lets you scroll back through your conversation using the up arrow key. When you land on the point you want to go back to, press Enter and you'll get a few options:

Restore code and conversation - rolls back both your files and the chat
Restore conversation - rewinds the chat but keeps your code as-is
Restore code - reverts your files but keeps the conversation
Summarize from here - condenses everything from that point forward
Never mind - cancels and takes you back to where you were

This is really useful when Claude has gone down the wrong path and you want to undo a series of changes without manually reverting files yourself.

Stash Your Prompt with Ctrl + S

This one would have saved me a lot of time if I'd known about it sooner. If you're mid-way through typing a prompt and realise you need to ask something else first, press Ctrl + S to stash it. Your current prompt gets set aside, you can type and submit something else, and then the stashed prompt automatically restores in the input field, ready for you to send or stash again.

If you decide you no longer need the stashed prompt, just press Ctrl + C to get rid of it.

Before I knew this existed, I was copying my prompt to the clipboard, typing the other thing, and then pasting it back in. Not the end of the world, but once you've done that a few times in a session it gets old fast.

Paste Images Directly into Claude Code

Something I didn't expect from a terminal-based tool: you can copy and paste images right into Claude Code. Just copy an image and paste it into the input field, then ask questions about it. Useful for things like sharing a screenshot of an error and asking what's wrong, pasting a design mockup and asking Claude to build it, or getting help interpreting a diagram or chart.

Bash Mode with `!`

Prefix any input with ! to run it as a bash command directly from Claude Code. For example, !npm run typecheck will run your typecheck and show the output. The useful part here is that any error messages from those commands are now in Claude's context, so you can immediately ask it to help fix whatever went wrong.

You can also run long-running processes like !npm run dev and then press Ctrl + B to send it to the background. You'll see a message like:

Command was manually backgrounded by user with ID: be96u9i91. Output is being written...

A background task indicator will appear, and you can use the arrow keys to navigate to it and press Enter to view the shell details:

Shell details

Status:  running
Runtime: 2m 15s
Command: npm run dev

Output:
> dev
> react-router dev
  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose

From the shell details view, you can press X to stop the background process, or press the left arrow key to go back to your conversation.

This means you can keep your dev server running in the background while continuing to work with Claude in the foreground. Because the output is being captured, Claude can see what's happening with the process so if something crashes or throws an error, it already has that context and can help you debug it.

Suspend Claude with Ctrl + Z

If you need to run a bash command outside of Claude, something you don't want in its context, press Ctrl + Z to suspend the process. Run whatever you need to in your terminal, then type fg to bring Claude back. Handy for things like checking credentials, running unrelated scripts, or anything you'd rather keep out of the conversation.

Ending and Resuming Sessions

Press Ctrl + C twice to end your current session. Claude persists sessions locally, so when you exit it gives you a command to resume that session, something like claude --resume <session-id>. Just copy and paste it to pick up where you left off.

If you've already closed the session and didn't save the command, no problem. Open Claude Code and use the /resume slash command to browse your history.

If you just want to jump straight back into your most recent session, claude --continue does exactly that.

Managing Permissions

When Claude needs to run something, it will ask for permission with a few options:

Yes - allow it this once
Yes, and don't ask again for... - allow it going forward
No - block it, with the option to give a reason or suggest a different command

These choices are saved to a file called settings.local.json inside the .claude folder in your project. Inside that file you'll find a permissions property with an allow array listing everything you've approved. You can edit this manually to add commands, for example:

{
  "permissions": {
    "allow": [
      "Bash(pnpm typecheck)",
      "Bash(pnpm *)"
    ],
    "deny": [
      "Bash(git push *)"
    ]
  }
}

Use wildcards to allow a range of commands—Bash(pnpm *) will permit any pnpm command. Use deny to explicitly block things you never want Claude to run, like Bash(git push *).

Permissions aren't limited to bash commands either, they also cover things like web search and other tools.

By default, settings.local.json is ignored via .gitignore so your permissions stay local to your machine. If you want to share them with your team, rename the file to settings.json.

Hope this helps you move faster with Claude. Have fun.

How I built a practical agent skill that turns rough READMEs into polished project docs

Debbie O'Brien — Tue, 24 Mar 2026 21:44:06 +0000

If you're new to agent skills, start with my beginner guide first:

What Are Agent Skills? Beginners Guide

That post covers what skills are, how they get loaded, and how to build a tiny one from scratch.

This post picks up where that one stops.

Instead of another tiny example, I want to show you what a practical skill looks like when it solves a real problem.

We are going to take the idea of a skill and use it to turn rough project READMEs into polished docs that are consistent, accurate, and reusable across repos. I picked README generation because the output is easy to judge, it comes up again and again, and once you get it right for one project you want the same quality bar everywhere.

The problem with one-off README prompts

You can absolutely ask an agent to improve your README and get something decent back.

Sometimes it will even be very good.

But if you do that across multiple projects, the cracks show up quickly:

badge styles are inconsistent
section order changes from repo to repo
install commands drift away from the actual package manager
social links get guessed
simple projects end up with bloated READMEs
the agent repeats the same repo-scanning work every time

That is exactly the kind of problem skills are good at solving.

Not because they magically make the model smarter, but because they turn a vague prompt into a reusable workflow.

The first version was just one file

I did not start with a big architecture.

The first version of readme-wizard was just a single SKILL.md with instructions telling the agent to:

detect the project name, description, license, git remote, package manager, and CI setup
add a better structure to the README
use shields.io badges
include a Quick Start section with real commands
show a project structure tree
add contributor avatars, documentation links, and optional social badges

That first version worked.

And that matters.

One of the easiest mistakes to make with agent workflows is over-engineering too early. A single file is often enough to prove whether the workflow is useful before you invest more time into it.

Here is the important part: start with the smallest thing that can produce a useful result on a real project.

What broke in practice

Once I started testing the skill on real repos, the limitations showed up quickly.

The main issue was not that the agent could not write a README. It could.

The issue was consistency.

The single-file version was asking the SKILL.md to do too many jobs at once:

writing guidance
badge formats
project-type adaptation rules
README structure templates
Mermaid diagram templates
instructions for how to detect project metadata

That creates a few problems.

First, the file gets bloated fast. By the time I had all those rules and templates inline, it was over 150 lines and hard to maintain.

Second, the agent had to figure out how to inspect the repo on every single run. There was no scanning script yet — just instructions saying "detect the package manager, find the license, parse the git remote." The agent would improvise that detection work each time. Sometimes it got it right. Sometimes it missed a CI workflow file, guessed at the wrong package manager, or invented social links that did not exist.

Third, all of that detection reasoning burned tokens and produced inconsistent results. The kind of work that should be boring and repeatable was instead fuzzy and error-prone.

The turning point: treat the skill like a workflow, not a prompt

That was the point where the skill stopped being just a better prompt and started becoming a real workflow.

The structure ended up looking like this:

.agents/skills/readme-wizard/
├── SKILL.md
├── scripts/
│   └── scan_project.sh
├── references/
│   └── readme-best-practices.md
├── assets/
│   ├── badges.json
│   ├── diagrams.md
│   └── readme-template.md
└── evals/
    └── evals.json

Every part has a different job. And that is the point.

`SKILL.md` became the orchestrator

Instead of being one giant wall of instructions, SKILL.md became the thin coordinator.

Its job is to define the workflow:

run the scan script
read the README best-practices guide
build from the template
pull badge formats from the badge catalog
validate against the eval assertions
only load diagram templates if the project actually needs them

That is a much better use of the main skill file.

It keeps the top-level instructions focused on sequence and judgment instead of burying everything in one place.

Here is what the workflow section of the final SKILL.md looks like:

## Workflow

### 1. Scan the project
Run `scripts/scan_project.sh <project-directory>` to collect structured JSON metadata.

### 2. Read the best practices guide
Read `references/readme-best-practices.md` before writing.

### 3. Build the README
Use `assets/readme-template.md` as the base structure.
Replace {{PLACEHOLDER}} markers with actual project data from the scan.

### 4. Add badges
Read `assets/badges.json` for the full badge catalog.
Only include badges for things that actually exist.

### 5. Validate the output
Review the generated README against the assertions in `evals/evals.json`.

### 6. Optionally add a diagram
Only read `assets/diagrams.md` if the project has multiple components.

Short, focused, and easy to follow. Each step points to another file instead of trying to carry everything inline.

The script handled the mechanical work

The biggest improvement was moving repo scanning into a script.

The skill now runs scripts/scan_project.sh <project-directory> and gets structured JSON back with things like:

project name
description
license
owner and repo
package manager
CI provider and workflows
social links
directory structure

Instead of the agent improvising that detection work every time, it runs one script and gets clean, structured data back. Boring and repeatable. Exactly what you want for metadata gathering.

The current reference version also goes a bit further. It checks local files first, then uses the GitHub API to look up the repo homepage and crawls it for additional social links. That is a good example of how a skill can evolve — start with the reliable local-file path, then add enrichment once the core workflow is stable.

References and assets gave everything a home

The remaining pieces fell into two folders.

references/readme-best-practices.md holds the writing guidance: section order, tone, project-type adaptation, badge rules, and common pitfalls. The agent only reads it when it is about to write, not every time the skill loads.

assets/ holds reusable inputs: badges.json for badge formats, readme-template.md for the base README structure, and diagrams.md for Mermaid templates when a project is complex enough to justify one.

This is where the skill becomes easy to customize. Want to change badge styles? Edit the badge catalog. Want a different README structure? Edit the template. Want to skip diagrams for simpler repos? The skill just avoids loading that asset entirely.

Keeping domain knowledge and data out of the main instructions makes the whole thing much easier to maintain.

Evals made the quality bar explicit

Once the skill was doing real work, I wanted a way to define what good actually meant.

That is what the evals are for.

The evals/evals.json file includes prompts for different cases:

a straightforward README improvement request
a casual "make this look professional" request
a minimal project that should not get bloated
a badge-focused request that should only generate real badges

I like this part because it forces the standards out into the open.

Instead of vaguely feeling that the README is better, you can check for specific things:

no placeholder text
badges only for real metadata
Quick Start commands that match the detected package manager
section depth proportional to the project
no fabricated social links

That makes the skill easier to improve without drifting.

The larger lesson

The interesting thing about this project is not really README generation.

The larger lesson is that a useful skill usually stops looking like a prompt pretty quickly.

It becomes a small system.

Some parts should stay flexible and language-driven.

Some parts should be deterministic.

Some parts should be reusable data.

Some parts should act as tests.

Once you see that pattern, it applies to a lot more than READMEs:

commit message workflows
code review checklists
release note generation
internal documentation standards
repo audits
team-specific engineering conventions

That is the shift I find most useful when working with agents.

You stop asking the model to improvise the whole workflow every time.

Instead, you give it a structure that makes good behavior easier.

If you want to build your own skill

If you want to build your own skill, this is the path I would recommend:

Start with one SKILL.md.
Test it on a real project as early as possible.
Watch for repeated logic and consistency failures.
Move mechanical work into scripts.
Move domain knowledge into references.
Move templates and data into assets.
Add evals once the skill matters enough to maintain.

That sequence keeps the architecture earned.

You are not building a folder structure for its own sake. You are extracting parts only when they prove they deserve to exist.

Try it yourself

If you want to explore the full tutorial series or inspect the finished reference implementation, the repo is here:

debs-obrien/learn-agent-skills

And if you just want to try the skill without building it yourself:

npx skills add debs-obrien/learn-agent-skills

Then open any project and tell your agent:

Improve the README for this project using the readme-wizard skill.

The point is not just that a skill can write a better README.

The point is how you get from a useful first draft to something reusable.

I Used Skill Creator v2 to Improve One of My Agent Skills in VS Code

Debbie O'Brien — Sat, 21 Mar 2026 08:32:36 +0000

I just published a video showing how I used Skill Creator v2 to improve an existing AI skill inside VS Code, and honestly, I was seriously surprised at how much this thing does.

What impressed me most is that it does much more than just rewrite instructions.

It can:

review an existing skill
suggest targeted improvements
run evals against a baseline
compare outputs side by side
generate benchmark summaries
help optimize descriptions for better triggering

In the video, I ran it against a skill I had already created to see whether the updated version actually performed better, or if there was anything I was missing.

And it was a ton of fun.

The Skill I Tested

The skill I used for the demo was a skill I had already created called README Wizard.

It basically generates a polished, professional README for any project and is meant to kick in whenever someone mentions:

improving a README
project documentation
badges
first impressions for a repo
making a GitHub repo look more professional

It also checks project metadata, reads best practices, uses badges, Mermaid diagrams, and works from a README template. (need to create a video for this too.. on it)

So rather than creating a skill from scratch, I wanted to see if Skill Creator v2 could improve something real that I had already built.

Finding Skill Creator v2

The first thing I did was go to skills.sh and search for Anthropic.

From there, I found Skill Creator, and it now shows a summary of the skill which is nice.

The skill covers test case creation, evaluation and also runs parallel test cases with and without the skill to measure impact, capturing timing and token usage for comparison.

And on top of that, it generates an interactive browser-based reviewer showing outputs, qualitative feedback, and benchmark metrics.

It also includes description optimization, which is really important for improving skill triggering accuracy by testing realistic trigger and non-trigger queries.

Installing the Skill

Installing it was pretty straightforward.

I copied the install command from the page, pasted it into the terminal, and then selected where I wanted the skill installed.

Looking Inside the Skill

Before running it, I wanted to see what was actually inside the Skill Creator skill.

Skills are written for agents, not really for you to sit there and read through line by line, but I always like to have a look.

And this one is pretty complex.

It includes:

the SKILL.md file
its own agents
references and schemas
Python scripts
an eval viewer
review tooling

What I found really cool is that it comes with its own agents:

an analyzer agent
a comparator
a grader

The analyzer looks at comparison results and tries to understand why the winner won and generate better suggestions.

The comparator compares two outputs without knowing which skill produced them.

The grader evaluates expectations against the execution transcript and outputs.

Running It Against a Real Skill

I then used Skill Creator against my README Wizard skill.

I’ve done this a couple of times now, and I found that in VS Code I sometimes need to be a little more explicit if I want the full benefit of the sub agents.

Claude seems to pick that up more naturally because the skill was built for it, but in VS Code I wanted to make sure it really used everything available.

So I’d definitely encourage being explicit there.

What It Found

Very quickly, it started identifying issues with my skill.

Things like:

the workflow being under-specified
missing guidance for handling existing or missing READMEs
README best practices being too thin
sections that should only appear if relevant links exist
eval coverage being too small
missing edge cases
limited project detection

For example, it pointed out that a personal learning repo probably doesn’t need the same sections as every other project.

It also spotted that I only had two evals and suggested adding more realistic test cases, including edge cases like minimal projects and badge-focused README requests.

Applying Improvements

Once it had reviewed everything, it started applying targeted improvements across the skill files.

This part was honestly kind of exciting to watch because it moved fast.

It updated the skill instructions and made the guidance more explicit.

It improved the best practices.

It tightened up the logic around when certain sections should or shouldn’t be included.

And it expanded the eval coverage.

I could go through the changed files while it was working and see that it wasn’t just randomly changing things. It was making focused improvements that actually made sense.

That part gave me a lot of confidence.

Adding More Evals

One thing I really liked was how it expanded the eval set.

I had two evals.

It added more.

For example, it created cases around:

minimal project README generation
badge-focused requests

And these evals work like tests.

They include assertions such as whether the output has:

a project description
a quick start or usage section
appropriate badges
the right structure for the kind of project being documented

This was super useful because it meant I wasn’t just guessing whether the skill was better. I could actually measure it.

Running Sub Agents in Parallel

Then came one of the coolest parts.

It launched sub-agent runs in parallel.

It ran:

the improved skill
the old skill baseline

side by side across multiple test cases.

That meant it could directly compare the version with the new changes against the original version.

This is where the workflow really stood out to me. It wasn’t just making edits and calling it a day. It was actually testing whether the changes improved results.

The Results

After the runs completed, it graded all the outputs against their assertions and generated benchmark results.

The improved skill outperformed the baseline on two out of four evals and tied on the other two.

The overall result improved from 81 to 97.5.

That’s a 15.7% improvement.

Some of the biggest wins came from improving the skill’s ability to:

generate good content even when metadata is sparse
adapt README length and sections to different project types instead of always forcing the full template

The Workspace It Creates

Another thing I wanted to show in the video was the workspace it creates while doing all this.

It creates a workspace folder where it stores things like:

skill snapshots
old skill outputs
grading results
benchmark data
iteration files

You don’t necessarily need to go through all of that manually, but it’s very cool that you can.

If you want to inspect exactly what happened at each stage, it’s all there.

That level of visibility is really nice.

The HTML Eval Viewer

Then I asked whether there was a way to see the benchmarks in HTML.

And yes, there is.

Skill Creator has an eval viewer for that.

This was another really nice surprise.

It launched an HTML review page showing:

old skill vs improved skill
formal grades
pass/fail results
benchmark comparisons
review flows for feedback submission

It’s made for a human to read.

You can actually review what happened and decide whether you agree with the results.

I really liked that.

Description Optimization

And then, because apparently this skill wasn’t done showing off yet, I ran the description optimization flow as well.

This generates trigger and non-trigger queries to see whether your skill description is actually good enough to fire when it should, and stay out of the way when it shouldn’t.

That workflow lets you:

review trigger queries
review non-trigger queries
edit them
export the eval set
run the optimization loop

That is super valuable.

A lot of the time, the problem with a skill is not the logic inside it. It’s that the description is not specific enough, or not clear enough, for the agent to trigger it properly.

So I really liked that this was built in too.

Final Thoughts

If you’re already building custom skills for:

GitHub Copilot
Claude Code
or other coding agents

this is absolutely worth checking out.

And yes, the video is long.

But the skill does a lot, and I found it hard to cut it down because I kept finding more things it could do.

So I pretty much left it as is.

Have fun.

Watch the Video

If you’re creating your own skills already, or even just experimenting with prompts and instructions, I’d be really curious to know how you’re approaching it.

Build Websites, Games, and Teaching Resources With Google Gemini for Free (No Coding Required)

Debbie O'Brien — Sun, 15 Mar 2026 17:14:32 +0000

I literally came home from a podcast interview and my husband said, "Debbie, I've built three websites." I said, "What?" And he said, "Yes, I've built three websites." And I said, "I heard you, but what?"

My husband is not in tech. He has never cared about anything I do in tech. He does not know how to build anything. He works in the public sector and is rarely on the computer. And yet, he was able to build three websites in 10 minutes. He watched a video for 10 minutes and just went for it. I knew I had to tell the world about this.

How he did it

He went to gemini.google.com. That's it. This is free. He paid absolutely zero money. I do have a pro account, but he has a free account and can just build websites. Seriously, you've got to check it out.

When you open Gemini, you'll see a bunch of options like create image, create music, create video, write anything, help me learn. There's a lot you can play around with. But there are a couple of other things that I find are a little bit hidden. If you click into the options, you'll see Canvas, deep research, guided learning, and more.

Canvas is the one we want. Open a canvas, pick the fast model (totally fine for this), and you're ready to go.

Building a Batman game for toddlers

After my husband built his three websites, the next day he started building games for our kids. I wanted to show you what that looks like so I typed in "build a Batman game for toddlers." That's it. A simple prompt.

The first thing that pops up is all this code. Don't be scared by that. As my husband said, "I watched it spit out all the code that you normally write by hand." I normally write this code by hand. That's the insane thing.

Once the code finishes generating, it jumps into preview mode. And there it was. A Batman city helper game where you move Batman to collect stars. I was just moving with the trackpad and it worked. It was actually really simple for toddlers to play.

Just use your imagination

The cool thing is you just have to have an imagination and think about how to make it better. I typed "can you add sound?" and Gemini added a cheerful ping whenever Batman catches a star or a balloon. I could hear the little sound effects and honestly it was amazing.

You can even select a specific area of the preview, drag a box over it, and ask Gemini to make changes right there. I dragged over the top area and said "can you add the person's name here?" You don't even have to specify "the right hand corner" or anything. Just drag and ask. It figured it out.

Building multiple things at the same time

Here's something people don't even know about. While one thing is generating, you can open a new canvas and start building something else. I had the Batman game going and at the same time asked it to create a website for a circus act.

One line. That's all I typed. And out came a full circus website. "A night of pure magic." It looked incredible. And I could iterate over it, add the actual address, YouTube links, whatever I wanted.

Then I created some games for learning numbers for toddlers. I used to be a school teacher. I used to have to prep and create all this stuff in my free time. And now I can just create resources on the fly.

The number learning game blew my mind

The toddler number game it created was called "Number Fun" with a bubble pop game. It actually spoke out loud and said "pop the bubbles in order, start with one." You go one, two, three. I tried doing it wrong on purpose and it said "find number four." It had a home button where you could click on count items and count fruits. One, two, three, four. It had sound you could turn on and off.

This is what kids want. This is the kind of interactive learning material that used to take ages to build. And I made it with one prompt.

Sharing your creations

You've got access to the code if you know how to code and want to tweak things yourself. But the really cool thing is the share button. You can copy the content, share it with someone, or just copy a link. My husband was sharing things with me saying "here's a website I've started, can you help me improve it?"

You can also go to previous versions and see changes saved. And there's an option to add Gemini features, which adds AI stuff to your creation. Great for writing stories. We actually created a book that reads the story to you. I can't even remember all the things we created in just a couple of minutes.

The one thing that is missing is there's no quick and easy deploy button. You can share a link and people can see it, which is kind of like it's deployed but not really deployed. It's a bit weird. But for getting a design together and having someone help you with the deployment part later? It works.

The only limit is your imagination

Whether you're creating games, building your own book, making material for teaching, or putting together a website and having someone help you with the deploy part, you're in control.

This is free. You might hit some limits if you keep going nonstop, and then you can pay for more. But to try it out, it costs nothing. Just go to gemini.google.com and start building.

I encourage you all to play around with this. Think about the possibilities. The technical barrier is gone. The only problem now is your imagination. So start being creative and just start imagining things.

Have fun building.

What Are Agent Skills? Beginners Guide

Debbie O'Brien — Wed, 04 Mar 2026 18:27:36 +0000

AI agents are smart. But they're generic. Your agent is trained on a ton of general knowledge, but it doesn't have your specific domain knowledge. It doesn't know your preferences, your team's conventions, or how you personally want things done.

When we learn a new skill — playing basketball, riding a bike — we're adding knowledge we didn't have before. Skills work the same way for your agent. You give it the domain knowledge it's missing, personalized to how you want things done.

What is a skill?

A skill is a reusable set of instructions that teaches an AI agent how to do a specific task well. Think of it like a recipe card you hand to a talented chef. The chef knows how to cook, but they don't know your family's secret sauce. The recipe card tells them exactly what to do.

Without a skill → the agent produces generic output
With a skill → the agent follows your instructions and produces exactly what you want, every time

At its simplest, a skill is just one file: a SKILL.md with a name, description, and instructions. That's it. You can add extras like scripts, references, assets, and evals — but you don't have to. All you need right now is the SKILL.md file.

Let's build one.

Build your first skill

Open VS Code in your project directory. We're going to create a good-morning skill step by step.

Step 1: Create the folder structure

Create a new folder in your project root. You can use .agents/, .github/, or .claude/ — they all work. The .agents/skills/ path is the cross-agent convention that works with Copilot. Inside that, create a skills folder, and inside that, create a folder called good-morning. This folder name is your skill's name.

your-project/
└── .agents/
    └── skills/
        └── good-morning/

Step 2: Create the SKILL.md file

Inside the good-morning folder, create a file called SKILL.md. It must be in capital letters — that's how agents find it.

your-project/
└── .agents/
    └── skills/
        └── good-morning/
            └── SKILL.md

Step 3: Add the frontmatter

Open SKILL.md and add the YAML frontmatter at the top:

---
name: good-morning
description: "A skill that responds to good morning with a cheerful greeting"
---

Two important things here:

The name must match the folder name. If the folder is called good-morning, the name must be good-morning. If they don't match, your editor will flag it.
The name and description are always in context. Every time you're working in this project, the agent sees the name and description so it knows what skills are available. Keep the description short and specific, this is how the agent knows when to use the skill.

Step 4: Write the instructions

Everything below the frontmatter is the skill body. This only gets added to context when the skill is called, not all the time. The agent only loads these instructions when it decides to use the skill.

Add the body below the frontmatter:

---
name: good-morning
description: A skill that responds to good morning with a cheerful greeting
---

# Good Morning Skill

When the user says good morning, respond with:

- "Hi Debbie, hope you have a great day!"
- Ask if they have done any sport today
- Include a funny joke about sports

## Example

**User:** Good morning

**Agent:** Hi Debbie, have you done any sport today? Here's a funny joke about sports: Why did the soccer player bring string to the game? Because he wanted to tie the score!

That's the complete skill. One file. A few lines of instructions. Make it as personal as you like, put your own name in there, change the topic from sports to whatever you want.

Test it

Start a new session from the same directory (skills are discovered at session start) and type:

Good morning

The agent finds the skill, reads the SKILL.md file, and responds.

In GitHub Copilot: "Hi Debbie, have you done any sport today? Here's a funny joke about sports: Why did the bicycle fall over? Because it was too tired from all that cycling!"

In Claude Code: Open Claude Code from the same project directory, say "good morning", and you get the same thing: "Hi Debbie, have you done any sport today? Here's a funny joke for you: Why do basketball players love donuts? Because they can always dunk them!"

Skills work across agents. The same SKILL.md file works in Copilot, Claude Code, and others. Each agent discovers the skill, reads the instructions, and follows them.

That's a skill in action. Now imagine instead of "good morning", the instructions told the agent how to generate a polished README, write commit messages in your team's format, or review code against your standards. Same idea, bigger impact.

How skills get loaded

Skills are designed to be efficient with context windows. They use a three-level loading system. The agent only loads what it needs, when it needs it.

Level 1 is always in the agent's context. It's just the name and description (~100 words). This is how the agent decides whether to use the skill. If someone says "improve my README", the agent scans its available skills and picks the one whose description matches.

Level 2 loads when the skill triggers. The full SKILL.md body with all the instructions, steps, and examples. This is ideally under 500 lines.

Level 3 loads on demand. Scripts, references, and assets that the agent pulls in only when it needs them. Scripts can even run without being loaded into context at all, saving tokens. And some resources might not load at all for certain projects. For example, a diagram template file only needs to be read if the project is complex enough to need an architecture diagram. Simple projects skip it entirely.

This matters because context windows are limited. A well-designed skill is lean at the top and detailed at the bottom.

Where skills live

Skills can be installed at two levels:

Project-level: in your project directory, available only when you're in that directory
Global: in your home directory, available from anywhere

Each agent checks slightly different locations:

GitHub Copilot (VS Code):

# Project-level (any of these work)
your-project/.github/skills/
your-project/.claude/skills/
your-project/.agents/skills/

# Personal (works from any directory)
~/.copilot/skills/
~/.claude/skills/
~/.agents/skills/

Claude Code:

# Project-level
your-project/.claude/skills/

# Personal (works from any directory)
~/.claude/skills/

The .agents/skills/ path is part of the Agent Skills open standard which is a cross-tool standard, but Claude Code uses its own .claude/ directory structure, not .agents/.

The skills ecosystem

There's a whole directory of skills at skills.sh where you can browse and discover skills built by the community.

To install a skill, use the skills CLI:

npx skills add anthropics/skills --skill skill-creator

This installs the skill-creator skill from Anthropic. A skill that helps you create other skills. One command and it's ready to use.

You can see what you have installed:

npx skills list

And search for skills:

npx skills find

Skills work across multiple AI agents — Copilot, Claude Code, Cursor, Goose, and many more. The skills CLI handles installing to the right location for each agent.

I Needed an APP to Track My Learning Journey, AI built it in less than half an hour with a single prompt

Debbie O'Brien — Sat, 17 Jan 2026 20:31:26 +0000

I have been trying to build a Learning Hub App for a good few months using various tools and have had many iterations back and forth on trying to get it to work and ended up going round in circles fixing one thing and breaking another.

Today I gave it a shot using goose coding agent and Claude Opus 4.5 as my modal. I used a simple prompt. No .prd file. Just clear instructions of what I wanted and I asked it to come up for a plan for it.

And it did. The plan was great. It started off with: What a great idea! Let me put together a comprehensive plan for this app. I'll call it "AI Learning Hub" - your personal knowledge management system for AI learning resources.

I got a Core Features Overview, Tech Stack Recommendation, Data Structure, UI Layout Concept, Build phases and some extra nice to have stuff for future improvements.

I asked it to change two things and then off it went. In less than half an hour it was not just built but tested before my eyes by using the Playwright MCP. I watched as it added links tested out the filters and used the site like a user would ensuring everything worked.

AI Learning Hub - Complete!

My agent told me: I've built your AI Learning Hub app! Here's a summary of what's been created:

Features Implemented
Add URLs with metadata fetching: ✅ Auto-fetches title, description, detects category
Categories: ✅ Blog, Video, Podcast, Course, Paper, Other
Learning workflow :✅ Queue → Learning → Completed
Search: ✅ Full-text search across resources
Category filter: ✅ Filter dropdown
Notes: ✅ Rich notes modal per resource
Drag & Drop: ✅ dnd-kit installed, drag handles ready
Content Ideas: ✅ Sidebar with types (Blog, Video, Tutorial, Thread)
Password protection: ✅ Environment variable based
Netlify ready: ✅ Config file created

And how do I add the URLs of the sites I want to add, easy. Just paste them into goose and it will use the Playwright MCP which I already configured and it will populate them all for me so I don't have to.

Conclusion

And that's it, finished and working in less than half an hour while I drank a beer on a Saturday night watching it all in amazement that something that should have taken me weeks to build was built before my very own eyes in minutes.

Now here is the thing. I didn't open an editor once. I haven't looked at the code. It is working as it should and that is really all I care about for this particular project. I studied coding. I care about the quality of code but right now I am ok with not caring. I am ok with trusting the agent and LLM to ensure the code is good and meets the standards it should.

I will add tests and check performance and out of curiosity I might just look at the code when doing the pr. But I am seriously blown away with how easy it is to do this.

Try it yourself

Want to give it a try yourself: Here is the prompt I used:

I would like you to build me an app so that I can easily manage urls for blog posts, podcasts, videos and other things that I would like to learn when it comes to AI. It would be great to be able to easily add the URL and then have a title and description field which can be populated when adding it. search by category would be great. I would be cool to have some sort of system like a todo list so when it is done it goes to a different place but is still findable should i want to share it with someone. maybe even notes so i could add some notes on it for later findings or note taking. should be able to prioritize things so that i learn things based on a particualar order maybe drag or drop so i can change it. it should be a fun app that i can easily deploy, nice and easy on the eye. it would also great to have a section where i can put ideas on content creation based off of the stuff I have learnt. these could be create blog posts, videos etc. just an idea and not sure if this will look great but we could try it out. can you come up with some sort of a plan for this.

How I Use AI Agents + MCP to Fully Automate My Website’s Content

Debbie O'Brien — Wed, 14 Jan 2026 19:29:47 +0000

Recently I have been playing with a lot of tools to help automate simple tasks just so I can keep my website uptodate. As I create a lot of content from videos to blog posts and appear as guests on many podcasts I want to have this reflected on my site as it's good to have all this info in one place to easily share with others and it's also great to look back on. But it is tedious and it takes time, time that I have very little of. So this is a perfect use case for AI to take over this task. So where do I start.

Before AI

First of all let me tell you what it is like to add a new podcast episode to my site. I use Nuxt content so basically each podcast is just a markdown file with some yaml. This yaml contains things like the date, the name of the podcast the image url and the host for example. Last year I was simply getting an old podcast episode and clicking duplicate in VSCode and then renaming everything with the new podcast information. So basically manually clicking the link to new episode and copying and pasting the information from that site where it hosted into my markdown file. Then I had to download the image and upload it to cloudinary, get the image name from there and paste that into my file. Cloudinary is great for managing images and keeping my site performant but the extra work of downloading and uploading the images was tedious and meant that sometimes it took me ages to add new episodes to my site cause I simply couldn't be bothered doing it.

Automating with Prompts and the Playwright MCP

I started to automate some of the process by using reusable prompts in VSCode. I created instructions for Copilot of what it needed to do and then all I had to do was press the play button to run the prompt in a new chat and then give it the URL for the podcast. I had the Playwright MCP installed so Copilot would use it to navigate to the URL of where the podcast was hosted and find the relevant information it needed to complete the metadata. It was pretty good and saved a lot of time and I could even bulk update new episodes by giving it more than one URL.

However the images where still an issue and I was tempted to actually just stop using Cloudinary just cause it was quicker and easier to use images stored in the public folder of my site. But then I would loose out on the benefits of Cloudinary and it's image optimization.

Automating with Goose, Playwright MCP, Cloudinary MCP & GitHub MCP

I then started playing around with Goose, a coding agent from Block. Goose is a desktop app although there is also a CLI available. I decided to give it a go and see if I could improve the way I automated this process. I probably could have continued playing around in VSCode and achieved similar but lately I have been trying to code, or should I say, get tasks done, without using an editor. As in just review the pull request later on CI and let the agent do it's thing cause I really believe this is the way we are heading so I want to keep experimenting on how it feels to code this way.

So I copied my prompt into Goose and saved it as a recipe. Recipes seem pretty similar to prompts but you can use parameters so I could add the podcast url as a parameter and it will automatically get detected. There are also a lot of other options which I haven't got round to properly checking out but this seemed enough for my use case. Now I have the Playwright MCP navigating to the site and getting all the info I need for the podcast page. I then just asked Goose to download the image for me and add it locally and it did. This was great but did I really want to just stop using Cloudinary just cause I was lazy!

So I thought what if Cloudinary had an MCP and then Goose could just use that MCP server to upload the image and then update the image metadata with the correct image id. Now if it could do that then all my problems would be solved. And so I looked in Goose's extensions and searched for Cloudinary and would you beleive it there was an MCP server for Cloudinary. Not only that but it actually worked. Goose used the Playwright MCP to navigate to the site and get all the content it needed including the image and then the Cloudinary MCP was used to add the image to my Cloudinary account using my API key stored in the extension's settings. It even figured out which folder to save it to without me asking.

And that was it. It all just worked. I checked my Cloudinary account and the images were there. I then asked Goose to run the dev server and verify it's work using the Playwright MCP by navigating to the podcasts page to ensure everything looked as it should. Not only could I see the browser being opened and see the new podcast episodes with images but I could also ask for a screenshot of the page.

Then one more thing of course. We had come so far so may as well finish it all off. I then asked Goose to create a pull request which it did using the used the GitHub MCP which I previously configured. I then reviewed the code just incase anything looked wrong, especially with regards to the cloudinary URL, even though I had visually reviewed it and as you can imagine, it was good to go. I merged it and new podcast episodes were added to my site.

Conclusion

So heres the thing. It took me time to figure all this out and set up the process and ensure it was all working. Yes it would have been quicker to copy and paste myself. But now it's done and the next time I want to add a podcast episode I just have to run my recipe in Goose and pass in the podcast URL. I am a guest on one tonight so when that is out I will be able to add it easily to the site. In fact if I had a team of people working on my site I could even share the recipe with them and they could simply run it.

I am using Nuxt content for my site which means I have no CMS. My content lives in markdown files and it makes it very easy as a developer to add content but perhaps not so easy for non developers. But now, now even my mother could add a new podcast episode to my site. That is just amazing. This is just my personal site but think about the possibilities of this use case for many other businesses.

I am very impressed with what Goose can do. The more I am using it the more it is blowing my mind. I am now going to go ahead and add other receipes for the rest of the content I add or perhaps just modify this recipe with parameters so I can have one recipe. I shall keep playing around. This is fun.

Let me know if you found this interesting or are doing something similar or have used any of the MCPs mentioned above. We are living in exciting times so if you haven't started to experiment yet then what are you waiting for. Just play around and have fun.

Debugging My Zsh Config With Goose (and Why Agentic AI Actually Helped)

Debbie O'Brien — Mon, 15 Dec 2025 15:37:30 +0000

I’ve been playing around with a few things recently and wanted to share a real experience that genuinely surprised me.

You might have seen the news from the Linux Foundation announcing the formation of the Agentic AI Foundation. As part of that, a few projects were donated into the foundation, including the Model Context Protocol (MCP), Agents.md, and Goose.

I’m guessing a lot of people haven’t heard of Goose yet. I hadn’t either until recently, so I figured I’d dig into it and see what it’s actually about.

If you want the full announcement, you can read it on the Linux Foundation website. This post isn’t about the announcement though — it’s about what happened when I tried to use Goose for real.

What is Goose?

Goose was released in early 2025, so it’s still very new. It’s open source (which I love), and it’s a local-first AI agent framework. It combines language models with extensible tools like MCP so it can actually do things, not just talk about them.

There’s both a desktop app and a CLI. I’m much more of a desktop app person than a CLI person, but everything seems to be going CLI these days, so I decided to give the Goose CLI a try.

The docs live at block.github.io, and I did start reading them. Like most people, I got through the first bit and then thought, “I’ll figure it out as I go.”

That decision led me directly into a very familiar kind of developer pain.

The Problem: Goose Wouldn’t Run

I installed the desktop app first and then followed the docs to install the CLI. The instructions said that after updating my .zshrc, I should be able to run the goose command.

I couldn’t. No matter what I did, I kept getting:

zsh: command not found: goose

I sourced my .zshrc. I ran goose --help. Nothing worked. The agent kept telling me everything was done correctly, and I kept replying with some version of, “No, it’s not working.”

This is where it got interesting.

Goose Didn’t Argue — It Investigated

Instead of looping on generic advice, Goose pointed out something important: terminal config changes are only picked up when a new session starts. That’s something I always forget.

So I closed the terminal, opened a new one, and tried again.

Still broken.

At this point, Goose acknowledged that something wasn’t right. It explained that if sourcing the file and restarting the terminal didn’t work, then one of two things was probably happening:

The change didn’t save correctly
Another startup config was overriding the PATH

Honestly, that explanation alone would normally make me sigh and prepare to lose an hour.

Instead, Goose suggested checking the file directly.

Letting an AI Read My `.zshrc`

Goose used a tool to open my .zshrc and read it. I didn't need to install this tool. Reading .zshrc files is not something I do often and I definitely don’t enjoy debugging them.

Goose scanned through all the usual stuff, pnpm, bun, nvm, PATH exports and then immediately spotted the problem.

When it had added the Goose PATH export earlier, it didn’t include a newline. That meant the new export was stuck onto the end of the previous line, creating a syntax error.

I wouldn’t have noticed that quickly. I was looking at the file and just seeing noise.

Goose explained exactly what went wrong, showed me the broken line, and explained that it should really be two separate lines.

Then it fixed it. It replaced the bad line with two clean, correctly formatted lines and even added a comment to make it clearer for the future.

After that, Goose asked me to restart my terminal one more time. This time, when I typed goose, the command worked. I could see all the available commands. Sessions, MCP servers, bundled tools, everything was there.

At that point, I just sat back for a second. Not because this was some massive, complex bug, but because this is exactly the kind of small, annoying issue that can completely derail your flow.

Why This Actually Matters

If I had debugged this myself, I would have figured it out eventually. But it would have taken time, frustration, and a lot of trial and error. Instead, the agent noticed something was off. It inspected a real config file and identified a subtle syntax error, fixed it safely and then it explained what happened.

That’s the difference between AI that answers questions and AI that actually helps you get unstuck.

I also didn’t know Goose could edit files like this. Seeing it work through the problem step by step, without pretending everything was fine when it wasn’t, made a big difference.

We don’t have the answers to everything as developers. That’s normal. What is changing is how quickly we can get unblocked.

If something doesn’t feel right, push back. Say it’s not working. Let the agent iterate. Let it re-check assumptions. That’s where this starts to become genuinely useful.

If you’re curious about Goose, it’s worth a look. And even if you’re not, this kind of experience is a good reminder that using AI well isn’t about shortcut, it’s about reducing unnecessary friction.

That’s it. Have fun experimenting with AI.

Useful Links:

How I vibe code: Improving my site design with Goose and Gemini 3

Debbie O'Brien — Thu, 20 Nov 2025 12:32:20 +0000

OK this was so much fun: Googles Gemini 3 is amazing. just got it to redesign my home page. I was having fun with this one so no real idea what I wanted just vibing along. It gave me a matrix style hero component which blew me away. This is so cool and the fact that I can spend less than an hour to improve my personal site is insane.

I used goose coding agent for this one which is open source and free and I just put my Gemini API key in which I am still using a free trial so my total cost for having fun was zero.

Was quite impressed that by giving Goose the link to an image it just downloaded it for me and added it to my public folder of my site. One less tedious task for me to do.

Towards the end I had the crazy idea of creating 7 hero component designs that change when you refresh the page. Why? Cause it's cool. This is maybe not how you build production apps but it sure is great for prototyping and getting to learn how new tools work and improving your communication with AI Agents and LLMs.

I encourage you all to take time out of your day and play around. Build a personal site even if you never deploy it. Improve your personal site and modify the design just for fun. Have fun cause Gemini 3 is pretty amazing and the tools we have available to us right now is insane.

And of course don't forget to run the Playwright healer agent after you have changed your design so your tests are updated. All it takes is a prompt. I didn't show it in this video but check out my other videos on Playwright Agents.

Have fun and happy vibe coding

Links:
Goose: AI Coding Agent: https://block.github.io/goose/
Gemini 3: https://blog.google/products/gemini/gemini-3/

Playwright MCP Servers Explained: Automation and Testing

Debbie O'Brien — Mon, 17 Nov 2025 13:10:33 +0000

Did you know Playwright has two MCP servers. Yes kinda confusing, let me explain it. The Playwright MCP server is great from Browser Automation, filling out forms for example or even using so LLM's can verify their work by opening the browser and taking a page snapshot to see it actually implemented what it said it did. It is built in to GitHub Copilot Coding Agent so if you assign a pr to Copilot it will use Playwright which you can see in the session logs. It is very cool indeed.

Then we have another Playwright MCP server called Playwright Test MCP which is built into Playwright test and is for, yes you guessed it, testing. It has some similar tools as the Playwright MCP server but it also has other ones that you only need if you are testing. It starts running when you use the Playwright Agents, Planner, Generator and Healer. However this MCP server only supports TypeScript/JavaScript for now.

So depending on your needs you can use one MCP server or the other. The Playwright MCP server you need to install while the Playwright Test MCP server is installed when you run an npx command when using the latest version of Playwright.

npx playwright init-agents --loop=vscode

The installing of the MCP server is done for you and it doesn't matter what other MCP server you have as the agent will only use the tools that it has assigned to it.

Check out the docs for more info on how to get started. Have fun and happy testing with Playwright MCPs

https://playwright.dev/docs/test-agents
https://github.com/microsoft/playwright-mcp

Fixing Failing Tests Automatically with Playwright’s New Healer Agent

Debbie O'Brien — Thu, 13 Nov 2025 12:36:29 +0000

If you’ve ever returned to your test suite to find a sea of red, you’re going to love this one. The Playwright Healer Agent is here — and it’s changing how we think about test maintenance.

What Is the Healer Agent?

The Healer Agent is part of Playwright’s new generation of AI-powered agents. Its goal is simple:

Automatically diagnose, repair, and re-run your failing tests.

Instead of spending time manually debugging selector changes or broken assertions, the Healer Agent can step in, analyze what’s wrong, and apply fixes directly to your test code.

And when it can’t fix something because the real problem is in your app or backend, it’s smart enough to mark that test with test.fixme, saving you time and frustration.

Watching the Healer in Action

When I ran the agent, it immediately found nine failing tests.
Then I walked away, literally went to grab a sandwich. By the time I came back, the agent had already finished its work.

Here’s what it did under the hood:

Debugged each failing test — stepping through line by line to understand the failure.
Identified UI mismatches — for example, a test looking for a textbox when the app now uses a combobox.
Applied fixes — updated the locators and assertions to match the actual UI.
Re-ran the tests — verified that the fixes worked.

One particularly cool example:
It saw that a test expected a heading with a certain regex pattern. But after checking a page snapshot, it found there were two separate heading elements. So it automatically adjusted the regex to make the test more flexible, then re-ran the test to confirm the fix.

Smarter Than Just “Making Tests Pass”

One of my favorite moments was when the agent encountered a failing test that wasn’t fixable through code alone.

The test was failing because the backend API wasn’t responding, it saw a Failed to fetch error in the console logs. Instead of forcing a bad fix or skipping it silently, the agent marked the test as test.fixme, with a clear message explaining why:

“Save operation is failing with fail to fetch error — likely a backend issue.”

That’s exactly how a responsible AI should behave — not hiding the problem, but documenting it.

Reviewing the Results

At the end of the run, the agent produced a summary:

✅ 104 tests passing
⚠️ 3 tests intentionally skipped (test.fixme)
🧠 Clear explanations for every change

Every fix was committed right in the codebase, complete with comments and annotations. Reviewing those changes is as easy as opening your editor and scanning the updated tests.

The Future of Test Maintenance

This is a huge leap forward for automated testing. The Playwright Healer Agent doesn’t just “fix” your tests — it understands them.

It’s capable of:

Reading and interpreting test logs
Inspecting DOM snapshots
Updating selectors, regex patterns, and assertions
Recognizing backend or configuration issues
Writing and verifying code fixes automatically

You can literally tell it:

run and fix my tests

…and then walk away. When you return, your test suite will be passing (or clearly annotated), ready for your review.

Final Thoughts

The Healer Agent isn’t just a convenience, it’s a glimpse of where developer tooling is headed.

We’re moving toward a world where AI doesn’t just write code, but maintains and adapts it alongside us.

If you haven’t tried it yet, give it a spin. Ask the Healer Agent to fix your failing tests, grab a coffee, and come back to review the magic.

👉 Happy healing — and happy testing!

I Built My Own AI Agent using n8n — And You Can Too

Debbie O'Brien — Thu, 06 Nov 2025 16:09:14 +0000

I recently built my own AI agent. Not because I needed one, but because I wanted to see how far I could take the current tools available. It turned out to be surprisingly straightforward, extremely flexible, and genuinely useful.

This post will show you what the agent can do and how you can build your own using n8n, without needing to write much code.

What My Agent Can Do

The agent runs as a simple chat interface where I can ask it different questions and request actions. For example:

Ask for the weather in a city.
Get my current YouTube subscriber count.
Check my recent running stats from Strava.
Have it send me an email containing a summary of the full conversation.

Here is what the chat looks like in use:

This is not necessarily something you must have, but it is a great demonstration of what is possible when you combine multiple data sources and let an AI model reason across them.

The Tool I Used: n8n

I built everything using n8n, a visual workflow automation tool. It allows you to drag and drop nodes to create automation steps, including AI reasoning steps.

One workflow contains:

A chat trigger
A large language model (Gemini in my case, but OpenAI also works)
Tools such as:

YouTube API statistics
Strava activity data
Weather API queries
GitHub issues
Gmail actions (send summaries, notifications, etc)

One important component is conversation memory, which allows the agent to recall previous messages in the chat.

Step-by-Step Quick Start Guide

Follow these steps to create your first simple agent.

Step 1: Create an n8n Account

Go to https://n8n.io and create a free account.
You do not need to enter payment details to start.

Step 2: Create a New Workflow

Inside n8n, click Workflows and choose New Workflow or use a template for free like the one I used: https://n8n.io/workflows/6270-build-your-first-ai-agent/

Step 3: Add a Chat Trigger

Search for AI Chat Trigger and add it to your workflow.
This will provide the public chat interface URL.

Step 4: Add an AI Model Node

Search for Google Gemini or OpenAI Chat Model.

You will need:

A Google Cloud key (if using Gemini)https://console.cloud.google.com/
Or an OpenAI key (if using GPT models)

Set a system prompt, such as:

You are a personal assistant that can answer questions and use tools when needed.

Step 5: Add Conversation Memory

Search for Memory and connect it to your agent. This allows your agent to remember context across multiple messages.

Step 6: Add Your First Tool (Example: Weather API)

Search for HTTP Request.
Set a request such as:

GET https://api.open-meteo.com/v1/forecast

Step 7: Save and Activate the Workflow

Click Save and then toggle the workflow to Active.

Copy the chat URL and open it in your browser.

Ask your agent something like:

What is the weather right now in Palma?

You just built your first agent.

Expanding with More Tools

Once the foundation is set, add tools one at a time. Examples from my workflow:

YouTube Data API to fetch subscriber counts
Strava API to retrieve recent runs
GitHub API to check open issues
Gmail node to send email summaries

Each tool is added as a separate node.
Connect it as a tool to the AI model.
Test each step individually before chaining them.

Final Thoughts

Building an AI agent today does not require advanced development skills. The hardest part is usually obtaining and configuring API credentials. Once those are set, everything becomes easier.

Experiment, try small ideas, and let your agent grow naturally as new needs appear.

If you build one, I would be interested in hearing how it went and what use cases you explored.

DEV Community: Debbie O'Brien

Getting Started with Claude Code: A Guide to Slash Commands and Tips

Slash Commands

/intro - Setting Up Your Project Instructions

/terminal-setup - Fixing Multi-Line Input

/model - Changing the Default Model

/usage - Checking Your Subscription

/context - Understanding What's in Your Context Window

/clear - Starting Fresh

/ide - Connect to Your IDE

/resume - Browse Previous Sessions

Tips

Interrupting Claude with Escape

Rewind with Escape + Escape

Stash Your Prompt with Ctrl + S

Paste Images Directly into Claude Code

Bash Mode with !

Suspend Claude with Ctrl + Z

Ending and Resuming Sessions

Managing Permissions

How I built a practical agent skill that turns rough READMEs into polished project docs

The problem with one-off README prompts

The first version was just one file

What broke in practice

The turning point: treat the skill like a workflow, not a prompt

SKILL.md became the orchestrator

The script handled the mechanical work

References and assets gave everything a home

Evals made the quality bar explicit

The larger lesson

If you want to build your own skill

Try it yourself

I Used Skill Creator v2 to Improve One of My Agent Skills in VS Code

The Skill I Tested

Finding Skill Creator v2

Installing the Skill

Looking Inside the Skill

Running It Against a Real Skill

What It Found

Applying Improvements

Adding More Evals

Running Sub Agents in Parallel

The Results

The Workspace It Creates

The HTML Eval Viewer

Description Optimization

Final Thoughts

Watch the Video

Build Websites, Games, and Teaching Resources With Google Gemini for Free (No Coding Required)

How he did it

Building a Batman game for toddlers

Just use your imagination

Building multiple things at the same time

The number learning game blew my mind

Sharing your creations

The only limit is your imagination

What Are Agent Skills? Beginners Guide

What is a skill?

Build your first skill

Test it

How skills get loaded

Where skills live

The skills ecosystem

I Needed an APP to Track My Learning Journey, AI built it in less than half an hour with a single prompt

AI Learning Hub - Complete!

Conclusion

Try it yourself

How I Use AI Agents + MCP to Fully Automate My Website’s Content

Before AI

Automating with Prompts and the Playwright MCP

Automating with Goose, Playwright MCP, Cloudinary MCP & GitHub MCP

Conclusion

Debugging My Zsh Config With Goose (and Why Agentic AI Actually Helped)

What is Goose?

The Problem: Goose Wouldn’t Run

Goose Didn’t Argue — It Investigated

Letting an AI Read My .zshrc

Why This Actually Matters

Useful Links:

How I vibe code: Improving my site design with Goose and Gemini 3

`/intro` - Setting Up Your Project Instructions

`/terminal-setup` - Fixing Multi-Line Input

`/model` - Changing the Default Model

`/usage` - Checking Your Subscription

`/context` - Understanding What's in Your Context Window

`/clear` - Starting Fresh

`/ide` - Connect to Your IDE

`/resume` - Browse Previous Sessions

Bash Mode with `!`

`SKILL.md` became the orchestrator

Letting an AI Read My `.zshrc`