Forem: Kourtney Meiss

Gotta Automate 'Em All: Pokémon help me do my work

Kourtney Meiss — Thu, 16 Apr 2026 16:15:16 +0000

I finally caved and bought a Switch 2. If I'm being honest with myself, it was only a matter of time before I fell victim to the fomo as videos of Pokopia started taking over my feeds. It's very quickly become one of my favorite games and most of my nights are now spent trying to make some progress on the storyline. So how does that relate to my work at all?

I wear a lot of hats: creating content, doing research, giving product feedback, fostering community, analyzing data, writing sample apps, and so many other things that don't always fit neatly into a category. Over the last year I've been integrating AI into my workflow to help me do all of these things. If you're in a similar spot, you may have a handful of specialized agents or prompts you call on manually. It works, but I knew I needed to unlock the next level so that instead of manually selecting which agent to use, an orchestrator would automatically route the request for me.

Building out my personal orchestration system meant rethinking agent delegation: what role each agent plays, when to call it, and what tools they need. I could've named them "researcher" and "blog writer" and called it a day. Instead, in an effort to bring some whimsy into everyday life I had some fun assigning a Pokémon to each of my agents based on what tasks they do.

The System: 1 Orchestrator, 8 agents

🧠 Orchestrator → Metagross

Role: Routes incoming tasks to the right, specialized agent.

Metagross has four brains joined by a complex neural network. No single brain does the work, but instead the four coordinate. As a Psychic type, they don't wait for instructions. They read the request and know which agent is the right one for the job.

🔬 Researcher → Alakazam

Role: Web search, technical deep-dives, knowledge gathering.

My researcher agent is Alakazam, which felt like an obvious fit since they have an IQ of 5,000 and continuously multiplying brain cells.

✅ Validator → Slowking

Role: Fact-checks claims, solves problems methodically.

Slowking fact-checks claims, challenges assumptions, and flags anything that doesn't hold up. The Pokédex describes him as: "Incredible intellect and intuition. Whatever the situation, he remains calm and collected." He doesn't rush. He reads the output, checks the claims, and stays methodical.

📅 Personal Assistant → Indeedee

Role: Manages calendar, email, scheduling, work priorities.

Indeedee can sense emotions through their horns and act as a valet, looking after their trainer's every need. It only felt right that they handle my calendar, email, scheduling, and prioritization.

📝 Friction Log → Rotom-Dex

Role: Documents developer experience observations.

Rotom with a Pokédex becomes a self-learning cataloger, documenting everything it encounters. Therefore, Rotom-Dex helps me write friction logs, which are structured walkthroughs of a developer experience: every rough edge, every confusing error, every moment of delight, documented as it happens.

💼 Meeting Prep → Porygon

Role: Synthesizes data into briefing packages.

Porygon helps me prep before I attend meetings. They can check my calendar, look up attendees, pull recent conversation history, and produce a clean briefing: who's in the room, what we've talked about before, and suggested talking points. Porygon is the first Pokémon created using modern technology, made entirely of programming code, built to move through cyberspace and process data. They were literally built to synthesize information and package it.

🔄 Repurposer → Ditto

Role: Transforms content across platforms.

Ditto rearranges their cellular structure to transform into any Pokémon they see. They don't create from scratch, but rather transform what already exists. Therefore, Ditto helps me repurpose content. I might give them a blog post and they help me transform it into a LinkedIn post or vice-versa.

📊 Analytics → Magnezone

Role: Connects to and helps analyze data on community engagement.

Magnezone has access to community engagement data from multiple platforms and helps me extract the insights I need to make decisions. Magnezone floats through the sky receiving and transmitting signals through their antenna, constantly monitoring their territory. They're always collecting.

🌟 Generalist → Mew

Role: Fallback agent, handles edge cases.

My generalist agent is Mew, the fallback for everything that doesn't fit neatly into another category. Mew contains the genetic composition of all Pokémon and can learn nearly any move in the game. When a task is too niche for a specialist, or I just need a second brain on something, Mew handles it. Every system needs a catch-all.

Example

Me:What should my top 3 priorities be today?"

Metagross routes to Indeedee.
Indeedee checks my calendar, scans recent emails, checks tickets assigned to me.

Metagross: You have a GTM release meeting at 2pm. Want me to prep you for it?

a. GTM release meeting at 2pm — you're presenting, need to prep
b. Developer feedback doc due EOD for the SDK team
c. Conference CFP deadline tomorrow

Me: Yes

Metagross routes to Porygon.
Porygon pulls the meeting details, looks up attendees, checks recent conversation history, and produces a briefing:

Metagross: Briefing ready. Want Alakazam to research any of the topics, or Slowking to validate the numbers?
a. 6 attendees: product, engineering, marketing leads
b. Last sync was 2 weeks ago & open action item was finalizing the developer messaging
c. Suggested talking points: SDK adoption numbers, developer onboarding flow, launch timeline

Me: I need to research what our community sentiment is about the SDK and compile into a report I can present at the meeting. Validate before compiling report. Open a ticket for tracking this.

Metagross routes to Magnezone who pulls community signal data.
Metagross routes output to Slowking who validates Magnezone's data.
Metagross routes to Mew to compile validated data into a report.
Meagross routes to Indeedee to create ticket.

Metagross: Report ready and ticket created. Slowking flagged the LinkedIn count — want to remove it or add a note about it?

Under the Hood

I use Kiro CLI, Amazon's agentic AI tool for my daily work, but you can definitely take this and adapt it to your tool of choice.

Each agent has a focused system prompt. Not a generic "you are a helpful assistant" prompt. A scoped, specific prompt that defines exactly what the agent does, how it responds, and what it ignores.

For example, Slowking's prompt doesn't say "check for accuracy". It says: "independently verify every factual claim, search for counter-evidence, flag sycophancy, check that links actually exist, and challenge my assumptions directly - not just the content."

Agents only get the context and tools they need. Any agents that produce writing have access to my style guide and bio. Only Indeedee has access to my calendar and emails. Only Magnezone has access to Common Room data. Scoped access keep each agent focused and reduce the risk of something going sideways.

Each agent has its own model. I can assign different models based on what the agent does. A deep research task might warrant a more capable model, whereas a quick scheduling task doesn't need it.

The orchestrator can chain agents. Magnezone doesn't just route to one agent and stop. It can pass output from one agent into another, running them in sequence when the task requires it.

Agents are set to auto-approve. By default, every tool call requires manual approval. I configured each agent's allowedTools so that trusted tools run automatically without interrupting the flow. Alakazam can search the web without asking. Indeedee can read my calendar waiting for me to confirm it's allowed pausing. The system runs end-to-end without me clicking approve on every step.

The system learns. Each agent has its own lessons file. When I correct an agent, it logs the lesson and applies it automatically at the start of every future session. I don't have to repeat myself.

Build Your Own

Try this prompt in whatever AI tool you use (Claude, ChatGPT, Kiro, etc.):

Review the list of tasks I do regularly and group them into distinct roles (e.g. researcher, validator, scheduler, content creator)

For each role, write a focused system prompt that defines exactly what that agent does, how it responds, and what it ignores

Write an orchestrator prompt that routes incoming requests to the right agent based on intent — include a delegation rules list with trigger phrases for each agent

Suggest which tools or integrations each agent should have access to

Suggest a model for each agent based on the complexity of its tasks

Add a self-improvement loop to each agent: when corrected, log a concrete lesson to a lessons file; at the start of every session, read that file and apply every lesson immediately

As always with AI, you should review the output and make any changes you see fit.

Next Steps

I would love to hear your thoughts in the comments.

Do you have a personal orchestration system?
If so, is there anythign you think I am missing?
What would help me level up this workflow?

Disclaimer: Pokémon and all related characters are trademarks of The Pokémon Company / Nintendo / Game Freak. This post is not affiliated with or endorsed by The Pokémon Company. Fan art is subject to The Pokémon Company's legal terms.

The Hidden Geometry Inside Claude That Nobody Talks About

Kourtney Meiss — Tue, 30 Dec 2025 14:17:51 +0000

Ever wondered how LLMs format code so perfectly? How do they know when to break to the next line? If you've followed my series, you know that AI can't visually see text like we do. It can't say "this word is too long for the line, put it on a new one.", since it operates in tokens. So what does it do? Spoiler, it's way more sophisticated than you'd expect.

The Process

Counts characters in the current line
References the maximum line width
Calculates remaining space
Compares with next word's length
Decides whether to break the line

Simple enough. But how it does step 1, counting characters,is where things get interesting.

The Geometry

Researchers found that LLMs build geometric structures called manifolds to handle character counting. This is a curved surface in six-dimensional space with reference points representing different character counts. But six dimensions is hard to wrap your brain around, so instead, picture an old spiral staircase. Each step represents a different character count: step 1 = one character, step 2 = two characters, and so on.

The staircase is made of creaky wood. When you step on step 5, steps 4 and 6 might creak too. This happens when LLMs aren't 100% certain—instead of "definitely 5 characters," it says "somewhere between 4 and 6 characters."

Why Build a Complex Structure?

Why not just count 1, 2, 3, 4 like humans?

The spiral structure is incredibly space-efficient and robust. Instead of separate storage for every character count, it uses a few dimensions to store hundreds of different counts. The overlapping "creaks" provide flexibility to operate with uncertainty.

Just like human perception, precision decreases with larger numbers. You'd struggle to distinguish between 1,000 and 1,001 items, but easily tell apart 1 and 2.

Boundary Detection

Once the model has the character count, it needs to detect if it's approaching the line boundary. It uses specialized components called boundary heads.

Picture two spiral staircases moving together:

Each step of the first staircase represents current character count
Each step of the second staircase represents a line width

When you're on step 35 of the current count and approaching a line width of 40 characters, a boundary heads activates: "Hey, we're getting close to the line width. Pay attention."

The Final Decision

For the last step, the model needs the next word's length. Say it's planning to add "aluminum" (8 characters).

Instead of simple subtraction, it plots both values on a two-dimensional graph to decide whether the word fits or needs a line break.

The Biology Connection

Here's the most fascinating part to me: LLMs independently discovered solutions remarkably similar to biology. The boundary-detecting features work like boundary cells in animal brains, which are the same neural mechanisms that help us navigate physical space. Pretty cool, huh?

You can read the complete research paper here.

The content in this post is part of my "Learning Out Loud" LinkedIn series, where I share things I've learned recently. Watch the video version on LinkedIn.

5 Tips to Stop LLMs from Losing the Plot

Kourtney Meiss — Tue, 23 Dec 2025 18:36:39 +0000

This post is adapted from episode 2 of my Learning Out Loud video series. If you missed my first post on why LLM responses degrade over time, check it out first to understand tokens, context windows, and context limits.

We've all been there—you start a conversation with an LLM and it's giving you great responses. Then 30 minutes in, it's like talking to a goldfish. Here are five strategies I've learned to keep conversations productive from start to finish.

1. Plan Before You Prompt

I know, I know -- nobody wants to spend time planning and writing docs before taking action. But hear me out! Creating a quick requirements document before you start actually saves time.

Think of it like a project kickoff:

What are you trying to build or solve?
Any specific requirements or constraints?
Any tools you want or need to use?
What does success look like?

It doesn't have to be fancy. Even a few bullet points help keep both you and the LLM on track.

2. Structure Your Prompts

LLM can parse your intent better when it's not buried in a wall of text. Use:

Headers for different sections
Bullet points for lists
HTML elements when you need them

For this reason, I write all my prompts in markdown files. Check out Obsidian as a great tool for this.

3. Start Fresh Conversations for New Topics

Don't try to cram everything into one endless chat thread. It's like trying to cover your entire project roadmap in a single meeting, it doesn't work.

Break conversations into focused sessions. New feature? New chat. Different problem? New chat.

Pro tip: Copy the requirements document from strategy #1 into each new conversation or save it to your AI assistant's saved context. This way every session starts with the same context about your project.

4. Keep an Eye on Context Usage

Here's something cool you might not know: many LLMs can actually show you how much of your context window you're using.

I use Amazon Kiro CLI daily, and there's an experimental feature that displays your context percentage right in the terminal. It's not on by default, but once you enable it, you'll never go back.

When you're getting close to the limit:

Ask the LLM to summarize what you've covered
Save the key points
Start a fresh session with that summary

5. Use Conversation Checkpoints

Every so often, just ask your LLM: "Are we still on track with what I'm trying to accomplish?"

If responses start getting weird or off-topic, that's your cue to start a new session. Think of it like a quick standup check-in.

Bonus feature: Amazon Kiro CLI recently added something like Git version control for your entire conversation history.

What's Working for You?

These five strategies have made a huge difference in my day-to-day work with LLMs. But I'm always learning and I'd love to know if there are any techniques you use that I didn't mention. Drop a comment below and let me know!

This post is part of my "Learning Out Loud" series where I share things I've learned recently. Follow me on LinkedIn to watch the video versions.

Context Rot: Why AI Forgets Your Perfect Prompts

Kourtney Meiss — Mon, 22 Dec 2025 18:55:26 +0000

You're deep in a coding session. Your AI assistant was crushing it for the first hour, understanding your requirements, following your coding style, and implementing features cleanly. Then suddenly, it's like talking to a goldfish.

Every new request introduces bugs. It ignores the constraints you set at the beginning. You find yourself repeating the same instructions over and over, wondering: "Are you even listening to me?"

If this sounds familiar, you're not alone. And more importantly, you're not going crazy.

Tokenization

Here's what's actually happening behind the scenes. AI doesn't process text like humans do. Before it can understand your words, everything gets converted into tokens. Think of it like feeding dollar bills into an arcade token machine, except you're feeding in words instead of money.

For example:

Input: "hello world"
Output: 3 tokens

Generally, one token equals about 3/4 of a word or 4 characters. Different models use different tokenization algorithms, which is why the same text might produce different token counts across providers.

If you're using API or CLI versions of LLMs, you're paying per token:

GPT-4o: $3/million input tokens, $15/million output tokens
GPT-4: $30/million input tokens, $60/million output tokens

But cost isn't the only concern.

Context Rot

Picture those tokens dropping onto a conveyor belt with fixed capacity. As you feed more words in, older tokens get pushed forward. When the belt fills up, tokens at the front fall off—and get forgotten.

That perfect prompt you crafted 20 minutes ago? Those crucial error messages you shared? If they've been pushed off the conveyor belt, they're gone from the AI's memory.

This is context rot, and it explains why your coding assistant seems to develop amnesia mid-conversation.

What You Can Do About It

The good news? Once you understand what's happening, you can work with it instead of against it. I've compiled strategies that have saved my sanity during long coding sessions.

Coming up next: Practical techniques to manage context rot and keep your AI assistant focused throughout your entire development workflow.

This post is part of my "Learning Out Loud" series where I share developer insights from real coding experiences. You can also watch the video version on LinkedIn. Follow for more practical AI development tips.