From "Raising Claude Code" to "Self-Growing Claude Code" — The Power of Metabolism

Recently, when talking to people who use Claude Code heavily, I ask, "Do you feel like your repository is getting cluttered? Does it feel like processing has slowed down a bit?" Almost everyone replies, "Yes..."

• Skills have increased significantly before you know it.
• Facts from six months ago remain in the context/ folder.
• CLAUDE.md has bloated so much that I can't grasp the whole picture myself.
• Processing has somehow become incredibly slow.

I realized recently that this isn't a problem of "how to raise" it.

It's a problem of "metabolism."

Just like the human body can't survive on nutrition alone. You need to metabolize, excrete, and build a constitution that is hard to get dirty in the first place. Repositories are exactly the same.

In this article, I'll write about four mechanisms to bring Claude Code to a "self-growing" state. For those who use Claude Code quite a bit and feel the management cost is getting heavy, this will really hit home.

■ Raising alone has limits

In the past, I've written many articles saying things like "Claude Code is a nurturing game."

https://x.com/0xfene/status/2042047157767926056?s=20

Creating skills, accumulating facts in context/, polishing CLAUDE.md... it was all about "adding."

This works incredibly well for the first few months.

The more you do, the smarter Claude Code feels, and it's a lot of fun.

However, after about six months, the view changes.

There are so many skills you don't even know what's there, and the facts in context/ start to deviate from reality. Even CLAUDE.md becomes so bloated that Claude starts overlooking important instructions.

In other words, a phenomenon occurs where "the more you raise it, the more it gets clogged."

That's when I realized.

Just putting things in isn't enough.

You have to rotate through the four pillars of intake, metabolism, excretion, and a "clean constitution," or the repository will die.

I will introduce those four in order.

■ ① Intake: Making it possible to import X posts immediately

The latest Claude Code know-how is almost all flowing on X.

• "Results skyrocketed with this prompt"
• "This combination of skills is insane"
• "I didn't know you could write hooks like this"

Every day, really good insights are flowing in.

But the problem is that most people just let it flow by.

To be honest, I was the same.

I'd take a screenshot thinking "I'll try this later," and a month later I'd look at my camera roll and think "What was this again?"

Or I'd bookmark a URL and never open it again.

Dead X posts were piling up in my phone and browser.

So, I created an "intake pipeline" for X posts.

Specifically, when you provide an X post URL, Claude Code automatically does the following:

• Summarizes the main points
• Categorizes with tags
• Suggests additions if it can be reflected in existing skills
• Drafts a skill if a new one seems necessary
• Memos it in context/ if it's just reference information

It's a mechanism that does this almost automatically.

Just by adding this, my behavior when looking at X changed completely.

Before, I was satisfied with a screenshot, but now when I see a post I'm interested in on X, I give the URL to Claude Code on the spot. It's processed smoothly, and three minutes later, the skill is updated.

"Finding good information" and "melting it into my Claude Code" become a single set of actions.

This is incredibly huge.

Really huge.

Because the latest know-how flowing in the community is continuously injected into your repository.

Whether you have this or not makes a world of difference six months later...!!!

Specifically, since a CLI is available for X, you can do this by linking it with Claude Code from the X Developer Console.

https://console.x.com/

I'll skip the detailed method since Claude Code will probably implement it for you, but if you're interested, please contact me!

■ ② Metabolism: Skills grow on their own through human feedback

This is the part I recommend the most.

It's about a mechanism called Gotcha, and it's seriously insane.

What it is, is placing a "Past Pitfalls" section at the end of each skill definition file.

For example, like this:

1## Gotchas (Past Pitfalls)
21. Do not reuse numbers from past articles
32. DAIJOBU Co., Ltd. uses the suffix notation. "DAIJOBU Corporation" is NG
43. Be wary of boastful numbers

That's it.

That's all.

But this is incredibly strong as a mechanism to grow a skill into an "experienced" one.

Specifically, the flow works like this:

1. User provides feedback ("This article has the same numbers as a past one")
2. That feedback is added to the Gotchas of that skill
3. The next time that skill is called, the Gotchas are automatically included in the prompt
4. Claude Code recognizes, "Oh, this is something I messed up before," and avoids it

In other words, with one piece of human feedback, that skill becomes permanently smarter.

This is truly shocking.

For example, my article review skill now perfectly remembers "don't use the same numbers as past articles" and "DAIJOBU Co., Ltd. is a suffix."

The 1on1 preparation skill remembers to "list 5 routes for a QA engineer's career."

The interview skill remembers to "always read before asking; skipping it loses trust."

I'm not saying this every time.

I just gave feedback once and added it to the Gotchas.

It feels less like "raising" and more like "letting it gain experience."

Just like giving feedback to a newcomer, the skill itself steadily becomes smarter.

In addition to this, another complementary mechanism is what I call Dreams.

This is a skill that extracts cross-cutting patterns across the entire repository that individual skills can't catch, on a weekly basis.

It finds repeating patterns from recent work logs and automatically writes them into context/dreams.md. Things like "I've made this judgment three times recently" or "this mistake is being repeated."

In short, it's a mechanism where today's self observes yesterday's actions.

With this, behavioral patterns you hadn't even noticed are verbalized and promoted to stock.

When Gotcha and Dreams start rotating, the repository enters a state where it "gains experience and gets smarter on its own."

This really works...!!!

■ ③ Excretion: Regularly posing "questions" to Claude Code

From here, it's about the "output" side.

To be honest, isn't everyone bad at cleaning?

I was terrible at it too.

I'd think, "I'm probably not using this anymore..." but I'd keep it because I was afraid of the decision to throw it away.

Before I knew it, I had a ton of skills, and half of them weren't being used.

At first, I tried to solve this with a mechanism like an "automated cleaning robot," but it didn't work very well.

The judgment was too difficult, and in the end, a human had to check it.

So I changed my policy.

Instead of making the mechanism clean, I changed to an operation where a human regularly poses "questions."

Specifically, once a month, I always ask Claude Code these three things:

• Are there any skills or agents that aren't being used? (List those not called in the last month)
• Is there any old context remaining? (List files that haven't been updated in over six months)
• I want to speed up Claude Code's processing; what is causing it to be slow?

I just ask.

There's no special mechanism.

But just by deciding to do this once a month, the repository cleaning starts to rotate.

This is because instead of deciding "whether to throw it away," I just "visualize the current situation."

When the list comes out, I can see at a glance, "Oh, I'm not using this anymore" or "This context is different from reality." The judgment itself ends in five seconds.

Change cleaning from "automation" to "regularization of questions."

Your heart will feel lighter.

Please try putting it in your schedule once a month.

It's great!

■ ④ Building a constitution that is hard to get dirty in the first place

This might be the most important thing I want to convey this time.

Cleaning hard is important, but it's overwhelmingly more cost-effective to create a structure that doesn't get dirty in the first place.

There are two keys to a constitution that is hard to get dirty.

The first is defining SSoT (Single Source of Truth).

SSoT means deciding on one place where "the correct version of this information exists only here."

For example, take the latest customer status.

If you scatter this in four places—"Notion customer DB," "context/clients/," "Slack memos," and "your own head"—discrepancies will definitely occur.

Six months later, you won't know "which is correct?" and the repository will turn into a swamp.

Instead, you decide that "the SSoT for the latest customer status is context/clients/{name}.md."

What's written there is the latest state of reality; Notion is basically a copy of that, and Slack is treated strictly as flow (information that flows by).

(In reality, we operate by basically centralizing customer information in Notion.)

Just by deciding this firmly at the beginning, information stops getting scattered.

The second is separating flow information and stock information.

This is incredibly effective.

• Flow information = Meeting minutes, 1on1 logs, business meeting memos, daily reports, research results (added chronologically, doesn't rot)
• Stock information = Facts that are correct at the current moment, states (overwritten, harmful if old)

If you don't separate these two, flow information will increasingly mix into the stock side, and the repository will become a swamp.

In my repository, flow information is physically separated under work/, and stock information is under context/.

Just by strictly following the rule "read the minutes and promote only new facts to stock," the context/ side can be kept clean forever.

The work/ side will pile up chronologically, but since it's "information that flows by," it's not harmful even if it gets old.

In short, you physically separate the place where things enter and the place where they accumulate.

If you do this, the cleaning itself becomes incredibly light.

The stock side is structurally hard to get dirty, and the flow side is not harmful even if it gets old.

If you design the constitution first, the subsequent operation will change 180 degrees.

■ From Raising to Self-Growing

I've introduced four things so far:

• ① Intake: Importing X posts immediately
• ② Metabolism: Skills grow on their own through human feedback (Gotcha + Dreams)
• ③ Excretion: Regular cleaning by posing "questions"
• ④ A constitution that is hard to get dirty: SSoT and Flow/Stock separation

When these four start rotating, what happens?

The repository enters a state where it "grows by itself."

At first, I thought Claude Code was a "nurturing game."

Creating skills, writing context, organizing CLAUDE.md... I was polishing it all by hand.

But when you set up these four, the view changes from a certain moment.

The repository becomes smarter on its own without you having to touch it.

New insights continuously come in from X, and skills gain experience and get smarter on their own. Old things are organized regularly, and since it's hard to get dirty in the first place, the maintenance itself is incredibly light.

When this loop starts rotating, the relationship with Claude Code truly changes.

It changes from the feeling of "polishing a tool" to the feeling of "growing together."

From the "era of raising" to the "era of setting up mechanisms to grow."

My Claude Code a year from now should be far smarter than what I could have raised by hand today.

With that in mind, I'm still refining the repository's constitution today.

I hope you all try to bring your Claude Code to a "self-growing" state too!

I'm sure the view will change significantly...!!!

*We have released a Claude Code training service for corporations!! If anyone is interested, please feel free to DM or comment! Members who are actually mastering Claude Code in B2B business will seriously train you from the very basics on the essential stories for utilizing Claude Code in an organization. We've made it a mechanism where you can take the course reasonably by involving subsidies, so please feel free...!!!