Tigerless Labs AutoHarness & Tigerless AI: Self-Learning Skills for Claude Code

If you use Claude Code regularly, you may already know this problem: you correct the AI once, explain how your project works, point out the conventions your team follows, and then several sessions later you find yourself explaining the same thing again.

That is the problem AutoHarness is trying to solve.

Created by Tigerless Labs, a nonprofit-oriented open-source AI lab building practical AI tooling, AutoHarness is a self-learning skill layer designed for Claude Code. Instead of asking developers to manually maintain every instruction or reusable skill, it learns from real coding sessions and turns useful lessons into native Claude Code skills.

The idea sounds simple, but the implementation addresses a much bigger question: what if the AI tooling around the model could gradually improve from the work you are already doing?

What Is AutoHarness?

AutoHarness is an open-source Claude Code plugin that observes your normal coding sessions and looks for useful patterns, corrections, workflows, and decisions that may be worth remembering.

When it identifies something reusable, it can turn that lesson into a skill stored in Claude Code's normal skill structure.

For example, imagine Claude Code generates an API route using this pattern:

throw new Error("User not found");

But your project consistently uses a structured helper instead:

return apiError(404, "User not found");

You correct Claude and explain that raw errors should not be thrown inside API routes.

Normally, that correction may only help the current conversation. In another session, you may have to explain the same convention again.

AutoHarness is designed to recognize that kind of useful correction and turn it into reusable knowledge.

From Coding Sessions to Reusable Claude Code Skills

The most interesting part of AutoHarness is that it does not require developers to create a separate training dataset or manually write every skill from scratch.

The learning process happens around the coding sessions you are already having.

A simplified workflow looks like this:

1. You work normally inside Claude Code.
2. A useful correction, preference, or workflow appears during the session.
3. AutoHarness reflects on the session and identifies reusable knowledge.
4. The lesson can become a native Claude Code skill.
5. Future usage determines whether that skill continues to be useful.

The generated skills are stored using standard SKILL.md files rather than being locked inside a proprietary memory format.

Project-level skills can appear under:

.claude/skills/

That means the result remains inspectable. Developers can see what was learned instead of relying on an invisible memory system.

AutoHarness Does More Than Keep Creating Skills

A common problem with long-term AI memory systems is accumulation.

If every correction becomes permanent memory, the system eventually becomes crowded with overlapping, outdated, or conflicting instructions.

AutoHarness tries to solve this through lifecycle management.

When two learned skills represent similar ideas, AutoHarness can consolidate or update them instead of continually generating duplicate files.

For example:

Skill A:
Use apiError() instead of throwing raw errors.

Skill B:
API routes should return structured apiError responses.

Instead of permanently maintaining both, they can be consolidated into a clearer skill covering the shared pattern.

The system also tracks whether learned skills continue to be useful. Skills that stop earning their place can eventually be moved out of active use rather than remaining permanently inside the working context.

This is an important distinction. AutoHarness is not simply trying to create more memory. It is trying to maintain a useful skill layer over time.

Your Manually Written Skills Stay Separate

Any tool that modifies its own instructions immediately raises an important concern: what happens to the instructions you wrote yourself?

AutoHarness addresses this with a self-authored-only ownership model.

The automated lifecycle management applies only to skills that AutoHarness created itself.

Your manually written Claude Code skills, project instructions, and other user-owned configuration are not supposed to be automatically rewritten, merged, or retired by AutoHarness.

This creates a useful separation:

• Your skills: manually maintained and controlled by you.
• AutoHarness skills: learned and lifecycle-managed by AutoHarness.

For developers who are cautious about self-modifying AI systems, this boundary may be one of the most important parts of the project.

Why the "Harness" Around an AI Model Matters

AutoHarness also reflects a broader change in how developers are thinking about AI coding agents.

The underlying language model is only one part of the system.

The instructions, tools, skills, memory, project context, validation mechanisms, and workflows surrounding that model form what developers increasingly describe as the harness.

A strong model with poor project context can repeatedly make the same mistakes. A well-designed harness can help the same model operate more consistently inside a specific workflow.

This is why the AutoHarness idea is interesting even if you are not looking for a traditional AI memory system.

It is essentially asking:

Can one part of the coding-agent harness improve itself based on actual work?

That is a more precise description than simply calling it a "self-improving AI."

The model itself is not being retrained. Instead, AutoHarness improves the reusable skill layer around Claude Code.

How to Install AutoHarness

AutoHarness is designed to work through Claude Code's plugin system.

You will need Python 3 available on your system because the project uses Python for its hooks and related tooling.

You can confirm Python is available with:

python3 --version

Then, inside Claude Code, add the AutoHarness marketplace:

/plugin marketplace add tigerless-labs/autoharness

Install AutoHarness:

/plugin install autoharness@autoharness

Then reload the plugins:

/reload-plugins

You can also restart Claude Code instead.

Because open-source projects can change quickly, I recommend checking the latest instructions directly on the AutoHarness GitHub repository before installing.

What Makes AutoHarness Different From Normal Claude Code Skills?

Claude Code skills themselves are not new. Developers can already create reusable instructions and workflows manually.

The difference is where those skills come from and how they are maintained.

With a traditional manual workflow, the developer has to notice a recurring problem, decide that it deserves a reusable skill, write the skill, update it later, remove duplicates, and eventually clean up anything that becomes outdated.

AutoHarness attempts to automate part of that maintenance loop.

Traditional Skill Workflow	AutoHarness Approach
Developer manually identifies reusable knowledge	Lessons are extracted from real coding sessions
Developer creates the skill	AutoHarness can generate the skill
Developer manually updates overlapping rules	Related learned skills can be merged or updated
Old skills remain until manually cleaned	Unused learned skills can be retired from active use
Manual skills may require ongoing maintenance	AutoHarness only manages the skills it authored

For developers who use Claude Code every day across large or long-running projects, that distinction could become increasingly valuable.

AutoHarness Is Part of a Broader Tigerless Labs Open-Source Ecosystem

AutoHarness is not the only open-source project being developed by Tigerless Labs.

You can browse the lab's broader work through the Tigerless Labs GitHub organization, which includes experiments and tools focused on AI agents, developer workflows, research, and automation.

The broader Tigerless AI website also publishes updates around AutoHarness and other work connected to the organization.

One additional project worth mentioning is influencer-discovery.

It is an open-source creator discovery and contact enrichment tool designed to help find creators across multiple channels and organize publicly available contact information.

The current project description covers creator discovery across 15 channels and can organize results into a Google Sheet.

It is a very different use case from AutoHarness, but both projects reflect the same broader idea: using agent skills to automate practical workflows rather than building another standalone AI chatbot.

Who Should Consider AutoHarness?

AutoHarness will probably make the most sense for developers who already use Claude Code regularly.

It may be particularly useful if you frequently encounter situations like:

• Repeating the same coding conventions to Claude Code.
• Correcting recurring architectural mistakes.
• Maintaining large project-specific instruction files manually.
• Writing reusable Claude Code skills after discovering useful patterns.
• Cleaning up skills that have become outdated.
• Working across projects with conventions that evolve over time.

If you only use Claude Code occasionally, the value of a continuously evolving skill layer may be smaller.

But for developers who spend hours inside AI coding agents every week, reducing repeated corrections could have a meaningful effect on workflow quality.

What AutoHarness Is Not

It is also important to keep expectations realistic.

AutoHarness does not retrain Claude.

It does not magically make the underlying model more intelligent.

And it should not be interpreted as proof that every coding task will suddenly perform better.

Its scope is narrower: it attempts to make the skill layer around Claude Code learn from real usage.

That narrower goal is arguably what makes the project interesting.

Instead of claiming to solve AI coding through another model, AutoHarness focuses on one practical source of friction developers already experience: useful lessons disappearing when a coding session ends.

Final Thoughts

The AI coding ecosystem is moving beyond simply asking which model has the highest benchmark score.

The surrounding system increasingly matters too: tools, memory, project context, skills, validation, and the way those elements evolve over time.

AutoHarness from Tigerless Labs is an interesting experiment in making that layer adaptive.

You continue working in Claude Code as usual. Useful patterns from real sessions can become reusable skills. Similar learned skills can be consolidated. Existing learned skills can evolve with new evidence. Skills that stop being useful can leave active memory. And your own manually created skills remain outside AutoHarness's management boundary.

If you are already using Claude Code heavily and are tired of repeating the same project conventions, AutoHarness is worth exploring.

Visit the AutoHarness GitHub repository to inspect the source code and installation instructions, explore more open-source projects from Tigerless Labs, or visit Tigerless AI for additional updates from the broader ecosystem.