While building Renma, I have often thought about how people will actually create Skills.
Writing every file by hand is possible.
But it is probably not how most people will work in the future.
LLMs are already good at reading existing documents, creating Markdown files, and reorganizing information. It feels natural to ask an LLM or an agent to help turn our knowledge into a Skill.
This may sound like Renma should include an LLM.
I don’t think it should.
The difficult part is not generating text
An LLM can generate a Skill-like document very quickly.
That does not necessarily mean the result is a good Skill.
It may be too large.
It may mix several responsibilities.
It may refer to knowledge that does not exist.
It may omit ownership, dependencies, or the reason why a rule exists.
The difficult part is not asking an LLM to write something.
The difficult part is giving it an environment where the result can be inspected, corrected, and reviewed.
Renma does not perform the work
Renma does not contain an LLM.
It does not choose a model.
It does not generate domain knowledge.
Instead, Renma provides structure around the work.
It can provide a scaffold.
It can define conventions for Skills and Context Assets.
It can inspect relationships and report problems.
It can make those problems understandable enough that an external LLM or agent can act on them.
The LLM performs the creation and modification.
Renma makes that work easier to delegate and review.
Diagnostics can become instructions
Traditional diagnostics are usually written for humans.
A developer reads an error, understands what it means, and edits a file.
With an agent, the same feedback can become part of an iterative workflow.
The agent creates an initial Skill.
Renma inspects it.
The agent reads the findings and updates the files.
A person reviews the result and answers questions that require human judgment.
This loop may continue several times.
Renma still does not need to call the LLM itself. It only needs to produce deterministic and actionable feedback that an LLM can consume.
I think this separation is important.
People still provide the knowledge
An LLM can help organize knowledge, but it should not silently invent the knowledge a team depends on.
People still need to provide the source material.
They still need to explain the purpose of the Skill.
They still need to answer ambiguous questions.
They still need to decide whether the result is correct.
The LLM can do much of the mechanical work between those decisions.
For example, it can split a large document into smaller Context Assets, add metadata, connect related assets, or revise files in response to diagnostics.
But when the source material is unclear, the right action may be to ask a question rather than generate a plausible answer.
That is also part of building a good Skill.
The repository becomes an interface
This makes me think of a Context Repository as more than a place to store finished knowledge.
It can also become an interface between people and LLMs.
People contribute knowledge, intent, and judgment.
LLMs perform creation and refactoring work.
Renma provides the structure and feedback that keep the work understandable.
Git records what changed.
Review determines what should be accepted.
The result is not simply generated content. It is knowledge that has gone through an engineering process.
Keeping the LLM outside matters
Models will continue to change.
Different teams will use different agents.
Some environments may allow cloud models. Others may require local tools or no LLM access at all.
If Renma embeds one particular LLM workflow, it becomes coupled to those choices.
By keeping the boundary clear, the same repository can be used with different models and agents. The validation can also run without an LLM, including in local development or CI.
This follows the same idea behind Context Repositories themselves.
Models and tools may be replaced.
Well-managed knowledge should remain useful.
Supporting creation without becoming the creator
I want Renma to help users build better Skills.
But that does not mean Renma needs to become an AI authoring tool.
Its role is to make the work explicit, structured, and reviewable enough that users can delegate much of it to the LLM or agent they choose.
The user brings the intent.
The LLM performs the work.
Renma provides the environment.
Maybe that is one useful role for a Context Repository: not only preserving knowledge after it has been created, but also helping people and their tools build that knowledge more carefully in the first place.
~ my tech diary ~ 