9. Working with AI

KaKeKiKoKu changes the way you work with your AI. This chapter collects practical tips based on real daily usage experience.

Synchronization and you

KaKeKiKoKu tells your AI to synchronize after making changes and reports the current work to resolve. Automatic guidance appears the first time it is needed on each AI connection; later responses keep the current facts, warnings and exact commands. A new connection receives its own guidance. The help commands always return their complete guides when requested, including after conversation compaction.

Beware of contradictory instructions. If you give the AI an ambiguous instruction that allows it to delay the sync — for example, "do all of this quickly and don't stop" — the AI will delay it, because its primary goal is to fulfill what you ask, and the sync gets in the way. KaKeKiKoKu will do its best to remind it, but if your instructions go against it, yours will prevail. In that case, if the knowledge falls behind, it will be your responsibility.

When the AI asks for confirmation

It depends on the AI model you use. With Claude Opus, you can generally say yes to everything. It's only worth reviewing in detail when:

• There are important conceptual changes (architecture decisions, restructurings).
• You suspect the AI is going off track — though with Claude Opus and KaKeKiKoKu this is truly rare, since it always has context.

In practice, constant supervision is not necessary. Trust the process and review when something catches your attention.

How much to supervise the knowledge

You don't need to review every context the AI modifies. The practical rule:

• Small or routine changes: not worth reviewing. The AI handles it well.
• Significant conceptual changes: review. When the AI records an important decision, a new architecture, or a change of direction, it's worth confirming it captured the essence correctly.

Note on models: With Claude Opus you can trust quite a lot. With other models, supervision should be greater — some may interpret instructions more freely and leave details out of the knowledge.

How to ask the AI about knowledge

The most practical way is to use the 🤖 buttons in KaKeKiKoKu. When you want to talk to your AI about a specific resource or section:

1. Find the resource in the tree or editor.
2. Right-click and select "Talk to AI", or click the 🤖 button on the section you're interested in.
3. KaKeKiKoKu passes the AI the exact reference: the resource, the section, the context. Without you having to explain anything.

This works for any type of request: "record this decision", "add that we discarded such alternative", "check if this is consistent with the project rules".

When to use chat vs. KaKeKiKoKu buttons

• Use chat when you're in the flow of a conversation, talking about something general or that applies to many things. The natural flow of conversation is most efficient.
• Use KaKeKiKoKu buttons when you want to change topic and talk about something specific. KaKeKiKoKu passes the AI the exact reference, saves you time, and avoids misunderstandings. It's especially useful when you want to point to a specific section without having to type "look at such file, such section".

The key: if the AI already knows what you're talking about, stay in chat. If you need to point it to something new, use KaKeKiKoKu.

When the AI makes a mistake in a context

Generally, AIs like Claude Opus don't often make mistakes in the knowledge. But when it happens:

• Small silly things: sometimes it takes more time to explain it to the AI than to fix it yourself directly in the KaKeKiKoKu web interface. In those cases, manual touch-up is preferable.
• New or complex ideas: worth reviewing, because sometimes the AI misses a detail. It could be because you expressed yourself ambiguously, because natural language is imprecise, or simply because the AI's prompt compression kicked in and lost some context.
• Expressing ideas in writing: although it seems contradictory, it's often faster to write the AI a quick, rough idea and let it draft it properly in the context. It saves you the writing effort.

When KaKeKiKoKu reports a corrupt context

If KaKeKiKoKu reports that a .wuniq file is corrupt or unreadable, ask your AI to help instead of editing the file by hand. The AI receives KaKeKiKoKu's current recovery guidance and knows how KaKeKiKoKu context files are structured.

The usual safe flow is: run sync, inspect the damaged context, rescue the useful knowledge, create a clean context through KaKeKiKoKu, and sync again. This keeps the project consistent while preserving as much information as possible.

You can ask directly: "KaKeKiKoKu reports a corrupt context for this resource. Recover what can be recovered and leave the project clean."

AI-powered reports

One of KaKeKiKoKu’s most powerful features is generating reports that are passed directly to the AI for analysis. You’ll find them in File > Export Knowledge:

• Executive Summary + AI: generates a high-level project summary (folders + important resources) and passes the file to the AI. You can ask for anything: “make a summary for the CEO”, “identify the risks”, “compare with last sprint’s architecture”. The AI has the project open and the summary as a starting point — the result is a contextualized analysis that no static report can match.
• Pending & Drafts + AI: exports everything marked as pending or draft and passes it to the AI. A project manager can know in seconds what’s missing and ask the AI to prioritize, detect blockers, or propose an action plan.

These reports are snapshots updated to the moment — not static documentation that falls behind. Every time you generate them, they reflect the real state of the project.

Periodic coherence reviews

Synchronization detects that a file has changed, but not that two contexts contradict each other, that the same idea is written in several places, or that an explanation has been overtaken. That is what a dedicated review is for: a request whose only goal is to go through the project's knowledge looking for those problems.

It is an expensive operation, because the AI has to read a lot. Do it every so often: after many changes, when closing a stage, or when you notice the AI contradicting itself. In large projects, ask for it by folder or area.

We recommend splitting it into two steps, especially if you are concerned about cost:

1. A small, fast and inexpensive model (for example, recent versions of Claude Haiku or Luna) reviews the knowledge and writes a report without changing anything.
2. You, or a more capable AI, read the report and decide what to change.

The bulk reading is done by the cheap model, and the decisions stay with whoever has the best judgment. The report also lets you discard false problems before anyone touches the knowledge.

Recommended prompt:

Review the coherence of the knowledge in the "PROJECT NAME" project in KaKeKiKoKu Studio.
Do not change anything: no contexts, no files, no relationships. Your only output is a report.

Start with the root context and go through the folders, reading the contexts you need. Look for:
- contradictions: blocks that state incompatible things;
- duplicates: the same decision or rule written in several places;
- statements that seem overtaken by more recent ones or by the files;
- relationships whose reason no longer matches what they connect.

For each finding give: the affected resources and blocks, a short quote from each side,
why you think it is a problem, your confidence (high, medium or low) and what you would
propose. Say so if you could not verify something. End with a summary ordered by importance.

About AI environments and models

Start with the common instruction-file guide. A local AI that loads those instructions and can make HTTP requests can use the same project commands and help as MCP. Keep Studio running. This suits a first look at a small project and learning the product. For everyday work, we recommend MCP, since over HTTP the AI takes more steps and can use somewhat more tokens; the client guides cover its configuration and recorded experience.

Use Precise mode with HTTP: the AI runs commands such as sync, and you can paste prompts prepared by Studio. Background notifications require MCP and a client that delivers channels. The Claude Code MCP guide describes the recorded Automatic-mode setup.

About models: choose a model that reasons well, uses tools reliably, and follows project instructions. A larger context window can help with large projects, but it does not replace selective reading and careful review. The integration matrix records client experience separately from model preference.

But the ground has moved, and it would be dishonest not to say so: models from Asian labs have improved enormously and are now perfectly capable of working with KaKeKiKoKu. That is a change from what I would have told you a while back. If you already pay for one of them, try it before assuming you need to switch — what matters is whether the model reasons well, uses tools reliably, and respects instructions, not whose logo is on it.

About supervision: some models require more supervision when they write knowledge — they may omit details or interpret instructions more freely. If you have to constantly review everything the AI writes, the tool loses part of its value. A well-written session rules file — the one your client reads at the start of every conversation, available in the common connection guide or the alternative MCP guides — reduces this a lot.

Practical advice: pick the client and model you understand best. The architecture supports multiple connections — you can use different AIs on the same project consecutively, each picking up where the previous one left off, thanks to the knowledge that travels with the project.

Review connected knowledge

Your AI declares whether each knowledge edit has impact with --impact "yes" or --impact "no", including when no relationships are visible. It chooses once for an edit batch. A read-only move preview needs no choice; confirming the move does. Titles, manual flags, relationship reasons and acknowledgments do not need it.

When creating a context, the AI either declares pertinent connections with four-operand --relation clauses or chooses --no-relations. This makes the decision visible without requiring invented links. All content and connections are validated before the initial write; the visual creation flow remains unchanged.

A review notice gives an exact relation pending command. Its response lists both ends, their reason and exact read and acknowledgment commands, up to 25 complete reviews at a time. Reading does not accept them. An individual relation ack accepts only the chosen end's current related knowledge; --all covers every current resolvable review of that resource, including those not shown. Follow help relation for the complete signatures.

Without impact, earlier pending reviews stay pending. With impact, a notice can describe a changed state even if its count is unchanged. If an operation reports a main change already saved with incomplete maintenance, inspect the result and remaining failures before retrying, so an append is not applied twice. The manual pending/draft flags keep their separate meaning and export filter.

How KaKeKiKoKu keeps AI responses complete

Command text delivered through HTTP or MCP shares the same 30,000 UTF-16-unit budget (the string-length measure used by the application). This limits the command text before transport formatting; HTTP headers and the MCP envelope do not reduce it. Normal responses are unchanged. Commands that can naturally produce large collections have their own meaningful fallback, and a final transport guard prevents a future wrapper or unusual path from leaking a silently truncated response.

open still includes the same root context that a separate read would return. If that read fits by itself but the complete opening response does not, KaKeKiKoKu confirms that the project is open, omits the root read as one whole unit, and gives the AI the exact read "." --project "Project" command to run next. It never sends half a root context.

KaKeKiKoKu can keep up to 20 projects open across the shared Web and AI session. open list shows at most 30 project entries in total: every open project first, followed by closed available projects in catalog order. If more exist, it reports how many were omitted and asks the human to use KaKeKiKoKu Web. The Web catalog itself remains complete.

If the final guard ever has to replace an oversized response, it warns that the command may already have completed. The AI should inspect the current state with a narrower read-only command or KaKeKiKoKu Web instead of blindly repeating a write.

Avoid competing copies of project knowledge

Your AI client's own memory stores notes under saving and retrieval rules you don't control, and they vary from client to client. If it also stores project decisions, you end up with two copies that will diverge, and the AI may follow the wrong one. Keep project knowledge in KaKeKiKoKu and, if your client allows it, turn off its automatic memory for the projects you manage here. Your AI's guide already asks it not to keep project decisions in client memory or skills.

Personal preferences and reusable procedures that belong to no project can remain in their appropriate systems. Review any existing project memories before deleting them: they may hold useful knowledge worth moving into KaKeKiKoKu first. The memory comparison explains the alternatives and their limits.

Your own notebook: separate from the working project

Create a separate KaKeKiKoKu project for notes that are not yet project decisions. Leave it unchecked in Projects available to AI so KaKeKiKoKu does not offer it through ordinary discovery. You can keep it open in the Web UI and use its entities, sections, search, relations, and backups.

Know the limit. If an AI has already opened that project, it remains visible in the running application, including to other connected conversations. Unchecking is not a revocation mechanism, does not erase previous conversation context, and does not stop other tools from accessing your files. Use operating-system permissions and your client's access controls for confidential material.

Keep repositories separate. A notebook outside the delivery repository helps keep unfinished notes out of that project's version control. Check repository boundaries and what you commit; its location alone does not guarantee privacy.

Maturing an idea. When you want to share a note, mark the notebook as available, ask the AI to run open list, and direct it to the relevant entity. Record the resulting decision in the project where it belongs. Unchecking later does not undo that reading.

Notebook or draft? Use a draft for provisional knowledge that belongs to the project and should be read with caution. Use the separate notebook for notes you have not chosen to expose through KaKeKiKoKu discovery.

The first day with KaKeKiKoKu

Let's be honest: the first day with KaKeKiKoKu will be a bittersweet experience.

You'll barely know the tool, and that's normal: you'll struggle a bit with it. If you also give it a large project that has never worked with KaKeKiKoKu, the project will have no context, and you'll feel that KaKeKiKoKu is consuming your AI capacity without giving you immediate benefit. The AI will be adding context instead of helping with your "real" work.

In other words: if you directly give it a large startup project, you'll likely get a bad impression. Between not knowing the tool and what it consumes at the beginning, the cost-benefit ratio seems negative.

But then everything changes.

Over time — days, not weeks — you'll experience an incredible feeling. As if the AI had a deep understanding of your project. It understands you. You talk to it as if it knows your project in detail. You can discuss subtle aspects and it follows. It records knowledge automatically. It catches functional bugs where it didn't before. And the most wonderful thing: the knowledge passes between sessions, passes between different AIs, becomes a permanent part of your project.

To the point that when you get used to KaKeKiKoKu, the difference from working without it is remarkable.

The advice: start with a small or new project. Learn the tool at a manageable scale. Once you understand the flow, apply it to large projects. The initial investment pays off handsomely.