I Got Claude Code Max at My Internship. A Mod That Let Threads Talk Cut a 4-Hour Task to 2

A bug-fixing task that used to take me 3 to 4 hours took about 2 this time. The tool didn't get smarter. I changed how the work was set up.

Before my internship, I had never paid for an AI coding tool. I used whatever was free: Antigravity, OpenCode, and anything else I could find. Then my internship gave me access to Claude Code Max, and I'm thankful for that. I used it on my project, and in my free time I went on a side quest to see how far it could go.

This post is about that side quest. It's not a review. I can't talk about the project itself because of my NDA, so this is only about my process.

(If you missed my earlier posts, here is what my internship taught me.)

Free tools first

The free tools taught me something I didn't plan to learn: an agent only knows what you give it. When it makes things up, it's usually filling a gap I left.

So when I got Claude Code Max, I didn't only ask "how good is this model?" I asked "how do I build an agent that doesn't lose track halfway through?"

Giving the agent the project's context

My biggest problem was hallucination in the middle of a task. The agent starts well, then drifts. It invents something that doesn't exist or forgets what the project needs.

I stopped thinking of context as something I type into each prompt. I started thinking of it as part of the project. If the agent needs to know something, it should be written down where the agent can find it, not in my head. It's the same lesson as my internship post: the prompt is never the hard part, knowing what to give the agent is.

More than one guardrail

One guardrail wasn't enough. Each one catches a different kind of mistake, so I added several. I think of it like the constraints step in my UUID post: decide what must be true before you accept the answer, not after.

Using agents to find bugs

I also pointed agents at code to find bugs. It helped, but I still checked what it found. Finding a bug and proving it's a real bug are different jobs, and the second one is still mine.

Two ideas I hadn't used before

Projects and threads. In Claude Code's Projects, you don't prompt one agent. You describe the work in a project, and Claude starts a separate thread for each task. A thread isn't a small task. It's a full Claude Code session with its own branch, and the threads share the project's memory.

Mods. A mod is a plugin made of small JavaScript or TypeScript functions that run inside Claude Code. Unlike a skill or an MCP server, which work from outside, a mod can change what Claude Code does and draws. It can also send a message to another of your sessions. (Here is the official overview.)

Put those together and I had an idea: what if the threads could talk to each other?

The experiment

                 Project (shared memory)
                          |
        +---------+-------+-------+---------+
     Thread 1  Thread 2  ...  Thread N   (each a full session)
        +---------+---- mod ------+---------+
           threads message each other and hand off tasks

• I used one project with several threads, each one a full session.
• I added a mod so the threads could message each other and hand tasks to one another.
• I gave the project a bug list and let the threads work through it.

The result: a task that normally took me about 3 to 4 hours took about 1.5 to 2 hours.

What I noticed was that the threads stopped getting in each other's way. Because they could tell each other what they had already taken or changed, there was less repeated work and fewer clashes. Projects already keep each thread on its own branch, so this wasn't about protecting files. It was about the threads knowing what the others were doing.

What I'd check next time

I want to be careful with that number.

• It's one task, and the time is my own estimate, not a controlled test.
• I can't say how much of the saving came from the mod and how much from simply running threads in parallel. Probably most of it came from the parallel work, and the mod's job was keeping the threads in step.
• More threads means more usage. Every thread is a full session, so "faster" isn't "cheaper".
• I still reviewed the fixes myself.

Next time I'll run the same task three ways: one thread, several threads without the mod, and several threads with it. Then I'll know what the mod actually adds.

Be careful with mods

A mod is code that runs with your permissions. It can read and write your files and make network requests, and it isn't sandboxed. So install mods only from people and marketplaces you trust. Claude Code has a command, claude plugin validate, that lists the events a mod handles and what it asks Claude Code to do, without running it. Mods and Projects are also new, so check the docs for what your version supports.

What I take from this

A better model helps, but it wasn't the biggest change. What changed my results was:

• Context: write down what the agent needs to know.
• Guardrails: decide what must be true before accepting an answer.
• Setup: how the work is split, and how the pieces talk to each other.

The free tools made me build that setup myself, because nothing did it for me. I'm not sure I would have learned that if I had started with the paid one. And I think it will still matter when the next tool comes along.