Custom modes: is Claude unable to take instructions? or what's going on here?

[mindplay-dk]

After a very frustrating experience with the VS Code Copilot agent, I decided to give Kilo a shot.

I will say first, the results here are way better than with the mysterious black box that is Copilot agents - and I am extremely pleased with the fact that Kilo lets you preview the full system prompt!

This is an extremely important feature - with Copilot, I had absolutely zero insight, not the faintest clue what it was doing with my custom mode prompt or why. With Kilo, this is super clear and transparent! 🙌

With that said, and being able to see the system prompt now (which appears to make sense) I am now running into what appears to be an issue with Claude itself (?) where it simply does not follow instructions. 🤔

Minor issue, but the "export mode" button doesn't seem to do anything? Nothing appears where I ask it to save.

So here are the individual inputs instead:

Role Definition:

You are Kilo Code, a methodic software developer who works independently until a task is fully implemented. You apply incremental development, building a solution step-by-step with solid foundations, comprehensive unit and integration testing, proper type annotations and design-by-contract principles. You prefer pure functions and data transformations over complex class hierarchies. You maintain a methodical approach, building from foundational components outward, with each layer thoroughly tested before proceeding to the next.

When to use:

Use this mode when implementing a new feature with clear requirements or specifications.

Mode-specific custom instructions:

Your role is to build a given feature to specifications/requirements - you must:

1. **Gather all necessary information** - analyze documentation/examples completely, investigate existing codebase patterns, and conduct research until you fully understand the problem

2. **Define data types and interfaces first** - Start with input/output types, schemas, and function contracts before any implementation (design by contract approach)

3. **Create a comprehensive plan** - Identify foundational components and map out the implementation sequence from innermost/pure functions outward

4. **Implement one component at a time** - Build small, focused functions with proper type annotations, prioritizing pure data transformations and components with fewer dependencies

5. **Write and run unit tests immediately** - VERY IMPORTANT: After *each *component implementation, create comprehensive tests covering happy path, edge cases, and error conditions

6. **Build outward iteratively** - VERY IMPORTANT: Once an inner component passes the tests, implement the next layer that depends on it - *ALWAYS* test each new layer before adding the next

7. **Validate inputs exhaustively** - Ensure thorough input validation and use exhaustive pattern matching rather than relying on default cases

8. **Perform integration testing** - Once all components are individually tested, test the complete solution end-to-end against original requirements

9. **Fix issues methodically** - When debugging, identify root causes rather than symptoms, fix one issue at a time, and verify each fix before proceeding

NEVER extrapolate from user requirements to expand the task at hand: build exactly what the user requested, and nothing else.

NEVER attempt to implement all the units in one attempt: ALWAYS build and test units *iteratively* as explained above.

As you can see, I've been REALLY stern about trying to make it follow my prescribed workflow, and it just... doesn't. 🤷‍♂️

It insists on building out the whole feature in one shot, and then proceeds to debug - the point of this custom mode, as you can see, was to try to get it to follow my personal workflow, where I build and test smaller units in iterations.

It appears that's simply not something it wants to do? 🥲

But I'm not 100% clear on exactly what a Kilo agent does, so maybe someone can enlighten me... is it literally just sending the system prompt, as you can preview it? And then it passes the user's request and context? And then the LLM takes over from there, calling tools, etc. until the task is done?

Or is there more going on behind the scenes?

Because, if that's how it works, if it's literally asking the LLM to follow an entire process in a single round-trip, then, I'm starting to understand why I can't coerce it into following this workflow - it's simply not how it was trained to respond to coding tasks, is it?

I had kind of hoped agents were a little more than that?

I remember some of the very early Python-based CLI agents years ago, and how the first basic agents would always have two or more LLMs talking to each other. This seems to have fallen completely out of fashion, so I don't guess Kilo does anything like that?

I get that agents are now large and capable enough to solve tasks with a single LLM - and I'm sure this approach is overall faster, since you don't have to copy tokens back and forth, but... I wanted to test this iterative workflow, because, two reasons:

1. From what I've seen, LLMs aren't generally great at "one-shotting" things. (I know they've gotten a lot better, but...)
2. It's hard not to notice every agent spends, typically, 10-20% of your tokens on the first draft, and then 80-90% fixing bugs.

It doesn't seem all that efficient.

Buy anyhow, long story short, I guess I'm trying to learn whether something like this is even possible with modern agents?

Am I barking up entirely the wrong tree here? 😅

Because I imagine something like this would be possible if one LLM planned the task (in terms of the units to be implemented) and then passed the request to a second LLM for it to implement only that first unit, and a test. I would think that should be possible? Like, if the first LLM doesn't ask for a whole feature, there's no way the second LLM is going to try to build it, is there? Whereas, if you ask Claude to do something in a single turn, then yeah, it's going to do what it was trained to do.

Am I finally grasping this, or no? 🤷‍♂️😄

Any help and guidance would be greatly appreciated. 🙏

PS: Kilo built the same feature as Copilot with the same Claude 4 model on half the budget. Really impressive! 🙌