Tools

Tools

Small instruments that apply Koòrdinated Thinking with what exists today, before the application does it natively. They are useful on their own and are not prototypes of it.

They live in tools/ and are licensed Apache 2.0, except where a file carries its own notice — see LICENSING.md.

Skills are grouped by the platform they install into, under tools/skills/: OpenAI/ for the Claude skill format, OpenWebUI/ for Open WebUI. The grouping is not cosmetic — the packaging differs and the two are not interchangeable, as the section on Open WebUI below explains.

The Claude skill

Available in both languages: koordinated-thinking-it · koordinated-thinking-en. They are the same instrument, each carrying its own language's reference files: the Italian one has the longer record of real use behind it, the English one is the published form. Install the one whose language you work in — see Italian and English.

The method stated as instructions for an agent rather than as a discursive document. Install it by placing the directory where the client looks for skills.

Tested and working with both Claude and ChatGPT. The packaging is the Claude skill format — a SKILL.md carrying front matter, plus a references/ directory — but the content is ordinary Markdown and is not tied to it: what makes the skill work is the instructions it states, not the container they travel in. With an assistant that has no skill mechanism, the same files serve as instructions and attachments.

It governs the drafting phase, and what it changes is the shape of the exchange:

• it opens a project by drawing out the general purpose, deriving verifiable objectives, proposing the actors and declaring the discipline, then writing v0.1 with the annexes already in place — what is undecided becomes an open point rather than silence;
• each iteration runs four phases: analysis, numbered consolidation questions each carrying a reasoned recommendation, contestation by the Critic, then drafting;
• it proposes drafting when a threshold is reached — two unrecorded decisions, an open point at risk of being lost, a contradiction with an earlier decision, a change of theme — instead of rewriting the document at every exchange or waiting to be asked;
• it enforces additivity literally. Replacing a section with "unchanged from v0.3", tabulating only the new decisions, or abbreviating the change log are named as prohibited, because each is a way of losing content while appearing not to.

The document it maintains has a fixed structure: purpose and nature of the document, actors, discipline, general purpose, objectives, descriptive chapters, then annexes A–F — open points, decision log, glossary, references, change log, parent and sub-specifications.

Three reference files ship with it. Two are readable on their own as a description of how the method is practised: references/document-template.md, the document model with all its annexes, and references/actors.md, the operational definition of the actors and the Critic's intervention formulas.

The third is the method document itself, carried as the skill's rationale layer: the skill prescribes, the document explains and justifies. The skill states the precedence — where the two appear to conflict SKILL.md prevails, and a divergence is flagged to the operator rather than resolved by amending either one. It also states when to read it, rather than loading it every session: when the operator asks what the method is or why it works, when a choice needs the reason behind a rule, when the fit of the method to an unusual problem has to be judged, or when an exact term or citable source is needed.

That copy is kept byte-identical to the source in the repository by check-version.sh, and stays under CC BY 4.0 rather than Apache 2.0: content does not change licence by being copied next to code.

One environment-specific detail when adapting it: drafting output is written to /mnt/user-data/outputs/, a claude.ai path. Elsewhere it needs changing.

The Open WebUI skills

tools/skills/OpenWebUI/ — the same instrument for a platform whose skill is a single Markdown file: no directory, no references/. Available in both languages, under it/ and en/.

That one constraint shapes the whole package. The four documents cannot live inside one skill without producing an ~86 KB block injected in full at every mention, so they become four skills attached to a single Model: the procedure, the document template, the actors, and the method document. Only their manifests — name and description — sit in the system prompt; the model pulls a companion's full text with view_skill when it actually needs it. It is the same progressive disclosure the Claude skill gets from its references/ directory, rebuilt out of the platform's own mechanism.

Role	Italian Skill ID	English Skill ID
the procedure — the one you invoke	koordinated-thinking	koordinated-thinking-en
document model, annexes A–F	koordinated-thinking-template	koordinated-thinking-template-en
actors' mandates, the Critic's checklist	koordinated-thinking-attori	koordinated-thinking-actors-en
the method document as rationale layer	koordinated-thinking-metodo	koordinated-thinking-method-en

The -en suffix is what lets both sets live in the same instance. The file is the ID with .md appended.

Import them one at a time through Workspace → Skills → Import, then tick all four under Workspace → Models → your model → Skills. Do not change the IDs: the main skill calls its companions by ID, and the ID is read-only once created.

Two requirements decide whether the package works at all, and both fail quietly rather than loudly. Native function calling must be on for the model — lazy loading depends on view_skill, and without it the three companions are simply unreachable while the main skill still appears to work. Every user of the model needs read access to each skill — attaching does not bypass access control, and skills that are not accessible are dropped with no error.

Beyond installation, the platform imposes two limits worth knowing before starting a project on it:

• the specification lives in the conversation. Skills here are plain text with no file system, so the document is produced as a Markdown block in chat. On a long project the conversation will be truncated — keep the current version in Notes, one note per project, replaced whole at every version, and paste it back when resuming. The skill asks for it rather than reconstructing it, because a specification rebuilt from memory is not a source of truth;
• no executable verification. The delivery checks rest on the model's judgement. Making them binding would take a Tool, not a skill.

The text is the corresponding Claude skill's, changed only where the environment forced it: delivery no longer writes to a file system, the pointers to references/*.md now address the companion skills by ID, and each file carries a licence note in its own right — which is also why these four are CC BY 4.0 rather than Apache 2.0. A file that travels alone has to say what it is.

Installation in full, including the Model's system prompt that carries the method's dispositions into every exchange: skills/OpenWebUI/README.md.

Repository scripts

tools/scripts/ — POSIX shell, no dependency to install.

Script	What it enforces
check-version.sh	The Markdown source and every HTML rendering must declare the same version, and every copy of the document shipped inside a skill must still be the document. Between source and renderings it compares the declared version, not the texts — only a person can do that. Between source and skill copies it compares the content: byte for byte for the Claude skills, and after removing front matter and licence note for the Open WebUI one, which wraps the text instead of putting it in a directory
check-selfcontained.sh	No published page may load anything from the network, and each must carry its Content-Security-Policy. Hyperlinks in the text are not resource loads and are deliberately untouched

Both run in CI on every change under method/, tools/skills/ or tools/scripts/.

The second one is worth a note beyond its function. The renderings carry their typefaces embedded and make no external request, so no reader's address is disclosed to a third party for the sake of a font. That property is held in place by two mechanisms rather than by good intentions: a Content-Security-Policy inside each document, which makes the browser block a remote resource added by mistake, and this check, which catches it earlier, at push time, where it is cheap to fix.