Usora Turns AI Debugging Sessions Into Reusable, Versioned Skills

Usora: Let Different AIs Continuously Precipitate, Validate, and Reuse Skills from Real Practice

Let the next time remember this time.

Over the past period, I have been using AI Agents like Codex, Claude Code, and Kimi more and more frequently in development.

They no longer just help me complete a few lines of code.

Troubleshooting problems, analyzing architecture, reviewing, refactoring, generating tests, formulating implementation plans... many tasks that originally needed to be done by myself are now becoming "done by humans and AI together."

But the more I use them, the more I clearly feel a problem:

AI is very powerful, but much of our experience is still one-off.

Today, I spent an hour with AI finding a great method for troubleshooting Vue memory leaks.

Next week, when switching to another project, I have to tell it again:

Which lifecycles should be checked;
How to troubleshoot event listeners;
How to handle keep-alive;
Where false positives are likely to occur;
What format the final report should be output in.

Or, after much effort, I finally tuned a set of Prompts that perfectly fit my project.

A few weeks later:

It might already be buried in some conversation history, never to be found again.

So I started thinking:

If AI has already begun participating in our daily R&D, then why can't these methods formed in real practice be precipitated like code?

This is the reason I started building Usora.

What is Usora?

Usora — The Aura of Practice

Usora is a personal Skill Hub and open skill ecosystem oriented towards the AI Agent era.

If explained in one sentence:

Let different AIs continuously extract, validate, and reuse Skills from real practice.

Official documentation: Usora — From Practice to Capability

What it aims to solve is not "how to write more Prompts."

But another problem:

How to gradually turn things completed by humans and AI together into truly owned capability assets?

I Don't Want to Start from a Prompt Every Time

Currently, when we use AI, most workflows are still like this:

Encounter a problem
   ↓
Open AI
   ↓
Re-describe the background
   ↓
Re-tell it the rules
   ↓
Repeatedly adjust the Prompt
   ↓
Get a decent result
   ↓
Close the conversation

Then next time:

Do it all over again.

What is truly wasted is not the few minutes spent writing the Prompt.

But what was already formed before:

Context + Method + Judgment Criteria + Workflow + Validation Experience.

These things are actually getting closer and closer to a kind of "capability."

For example:

frontend-memory-leak-analysis

It shouldn't just be:

Help me check if the Vue project has memory leaks.

A truly reusable Skill should know:

Where to start scanning;
Which APIs are high-risk points;
How to track child components;
How to analyze composables;
How to determine if event listeners are released;
How to check Timer / Observer / Worker;
How to handle keep-alive;
How to reduce false positives;
What should be output in the end;
Under which circumstances only analyze, not modify code.

At this point, it is no longer just a Prompt.

It is a set of:

Methods that can be executed by an Agent.

So, I Want AI to Start "Precipitating Capabilities"

This is also the core idea of Usora.

Suppose today I solved a complex problem together with Codex.

The traditional way is:

Conversation
     ↓
  Result
     ↓
    End

But in Usora's vision:

Conversation / Coding / Debugging
                ↓
             Activity
                ↓
             Foundry
                ↓
        Candidate Skill
                ↓
        Review / Validate
                ↓
              Skill
                ↓
               Hub

A practice should not disappear after the task ends.

It should have the opportunity to become a capability that can be directly invoked next time.

This is also the meaning behind the name The Aura of Practice:

Truly valuable capabilities come from the traces left by practice.

Foundry: The Most Important Part of Usora

There is a concept in Usora that I really like:

Foundry.

Literally translated:

A casting factory.

It is responsible for gradually "casting" the experience scattered in daily AI collaboration processes into Skills.

Ideally, we might generate a large number of such Activities every day:

Fixing a Vue keep-alive lifecycle issue

Completing a large-scale refactoring

Troubleshooting a memory leak

Designing a new CI Workflow

Optimizing a complex Prompt

Reviewing a Pull Request

Completing an architecture design

But not every Activity is worth becoming a Skill.

So what Foundry does is not:

Activity → Skill

But:

Activity
   ↓
Collect
   ↓
Analyze
   ↓
Extract
   ↓
Candidate
   ↓
Evaluate
   ↓
Validate
   ↓
Publish

That is to say:

First observe the practice, then decide what is worth keeping.

I think this is very important.

Otherwise, what you end up with is not a Skill Hub, but another garbage dump.

Multiple AIs Should Not Mean Multiple Isolated Islands

Another issue that I care about a lot is:

Currently, each AI has its own ecosystem.

Today using Codex.

Tomorrow using Claude Code.

Another task might be more suitable for Kimi.

More Agents will appear in the future.

If our capabilities can only be bound to a single AI:

Codex Skills

Claude Skills

Kimi Skills

Gemini Skills

Then as Agents increase, our capabilities will become more and more fragmented.

So from the very beginning, Usora does not wish to be bound to a specific model or Agent.

I prefer it to become:

                 Usora Hub
                     │
       ┌─────────────┼─────────────┐
       │             │             │
     Codex        Claude         Kimi
       │             │             │
       └─────────────┼─────────────┘
                     │
                  Gemini

Agents can change.

Models can change.

IDEs can change.

But:

Your capabilities should belong to you.

But If All AIs Can Modify Skills, Won't It Get Out of Control?

It will.

So Usora is not designed as:

All Agents can casually modify Skills.

Instead, it distinguishes two roles.

Candidate

Other AIs can:

Observe practice
Analyze Activity
Discover methods worth precipitating
Generate Candidate Skill
Propose improvement suggestions

But cannot publish directly.

Maintainer

The Maintainer is responsible for:

Review
Evaluate
Test
Version
Publish

By default, I tend to let Codex assume the role of Maintainer.

So the whole process becomes:

Claude ──┐
Kimi ────┤
Gemini ──┼──→ Candidate ──→ Maintainer ──→ Skill
Other ───┘

This way, the capabilities of different AIs can be utilized without turning your Skill Hub into an uncontrollable auto-generated repository.

Skills Should Also Evolve Like Code

Another principle:

Skills should not be a bunch of copy-pasted Markdown.

If it truly starts to become the capability infrastructure for AI, then it should at least have:

Version
Source
Change log
Validation
Testing
Release
Rollback

It should even know:

Why did this Skill appear?

From which practice did it come?

Who generated the Candidate?

Who Reviewed it?

What validation did it undergo?

Why did it change from v1.2.0 to v1.3.0?

Thus, the evolution of a Skill can become:

Practice
   ↓
Candidate
   ↓
Skill v1.0.0
   ↓
New Practice
   ↓
Improvement
   ↓
Skill v1.1.0
   ↓
More Practice
   ↓
Skill v2.0.0

This is also why Usora places great emphasis on:

Git, Versioning, Test, Release.

Because I hope Skills ultimately become a truly maintainable engineering asset.

From Skill Hub to Skill Market

If things only stop here, then Usora is just a:

Personal Skill Hub.

But I think there is an even more interesting direction.

Suppose one day, I have precipitated a very useful:

frontend-memory-leak-analysis

It has been validated through many real projects.

Then why should only I be able to use it?

Another developer might also have a very mature:

react-performance-audit

Or:

github-actions-release

Thus, the next layer naturally emerges:

Skill Market.

In the future, we can:

Discover
   ↓
Install
   ↓
Use
   ↓
Practice
   ↓
Improve
   ↓
Contribute

A Skill is no longer just:

A Prompt written by someone.

But:

A method continuously validated and improved by real practice.

What I Look Forward to More Is a "Capability Network"

If we push one step further, I think what is truly interesting in the future might not be:

Prompt Market

Or even just:

Skill Market

But:

Capability Network

Different people:

Developer A
Developer B
Designer
Architect
PM
Researcher

Different Agents:

Codex
Claude
Kimi
Gemini
...

And different Skills:

Debugging
Testing
Architecture
Design
Research
Release
Review
...

Ultimately connected together.

AI provides basic intelligence.

Skills provide methods.

Practice provides experience.

And humans decide:

What is worth keeping.

Why Is It Called Usora?

The full expression of Usora is:

Usora — The Aura of Practice

Aura is a lingering atmosphere, a trace.

I hope that every process of truly solving a problem does not completely disappear with the end of the Conversation.

But leaves something behind.

It might be a rule.

A judgment method.

A Workflow.

A Skill.

Or even eventually become a complete capability system.

So what Usora wants to express is:

Practice leaves an aura.

Practice leaves traces.

And what we need to do is turn these traces into capabilities that can be invoked again.

"Let the Next Time Remember This Time"

This is the Landing Page copy I finally settled on for Usora:

Let the next time remember this time

I really like this sentence.

Because it is basically the simplest explanation of the entire project.

Every day we are:

Coding
Debugging
Searching
Thinking
Reviewing
Designing

AI is also participating in these processes more and more deeply.

The question truly worth thinking about may no longer just be:

Can AI help me complete this task this time?

But:

After this time is completed, what can be left behind?

If next time we encounter a similar problem:

Can we avoid starting over?

Can AI know:

"We have solved this problem before."

If so,

then AI truly begins to move from:

Tool

to:

Partner

and further to:

Capability Infrastructure.

This is what I am building:

Usora

The Aura of Practice.

Let the next time remember this time.

Currently, Usora is still in the continuous design and development phase. Many designs regarding Skill Protocol, Foundry, multi-Agent collaboration, and Skill Market are also still evolving.

If you are also heavily using Codex, Claude Code, or other AI Agents, you are welcome to discuss together:

In the AI era, how do you think we should preserve our own "capabilities"?

You are also welcome to follow the project's subsequent progress.

GitHub: LuoMingxiang/usora: The Aura of Practice

If this direction happens to be a problem you are also thinking about, welcome to Star, Issue, or participate together in the design and construction of Usora.