You watch a great talk, read a course, keep a transcript from someone who really knows their craft. Lectic turns that material into expertise your assistant can apply: reviewers, checklists, decision frameworks, lessons — each one traceable back to the exact words that support it. Save once; every assistant you use can apply it, from any project, on any machine you point at it.

Start

pip install lectic
lectic setup

lectic setup connects Claude Code and Codex if they are installed, verifies the connection, and offers YouTube support. Then open either assistant, in any folder, and talk:

Save this for later: https://www.youtube.com/watch?v=…

What could my saved material become?

Use my Sales Training to review this call transcript.

That's the whole interface. No commands to learn, no goal to invent up front, nothing to re-upload later. lectic status shows where your knowledge lives and what is connected.

Use ChatGPT, Claude on the web, or Gemini? One more command gives them the same knowledge:

lectic share

It prints a private link and where to paste it. Your phone can post captures to the same link. To keep the link up when the laptop is closed, run the same server always-on (guide). Windows and macOS alike; Python 3.10+ is the only requirement.

What it does

Saving is free. Share a link, paste text, or point at a folder of transcripts. Nothing is processed until you want something from it, and your reason for saving stays separate from the source.

You don't need a plan. Ask what a collection could become and Lectic returns a ranked map of concrete jobs it can support: what you'd give it, what you'd get back, and where the evidence runs out. Pick one and it builds it.

Results carry their evidence. A review, a checklist, a lesson, a decision — every point cites the source passage behind it, and source statements stay distinct from the assistant's inference.

Build once, reuse everywhere. A method built from your Sales Training today reviews a different call tomorrow, from ChatGPT, Claude, Gemini, Codex or Claude Code, in any project, with no re-upload. Add sources later and earlier work is preserved.

Share what you know. lectic pack "FC 27" turns a collection into one file. Anyone runs lectic install on it and every assistant they use can apply it. Sources travel as links and are verified on the installer's own network, so nothing is redistributed (packs →).

What you can build

Capabilities follow the evidence. If the material lacks procedures, criteria, examples or conditions, the map says so instead of inventing them. These examples come from small synthetic fixtures and illustrate the kinds of transformation supported, not measured effectiveness. Explore the fixtures →

How it works

flowchart TD
    A[Capture or import] --> B[Source collection]
    B --> C[Durable expertise IR]
    C --> D[Capability Map or user goal]
    D --> E[Compiled method]
    E --> F[Text result or skill artifact]
    F --> G[Structure and evidence validation]
    G -. Optional facilitated comparison .-> H[Evaluate and refine]

The Expertise IR is the durable asset. Capability Maps are versioned interpretations of it; methods and outputs are builds from it. The MCP server and the installed skill are two interfaces to the same compiler, and Agent Skills is one output target. The core remains independent of a particular AI provider.

Knowledge lives in one Lectic home per user (~/.lectic, or LECTIC_HOME): original sources as content-addressed blobs, normalized segments, knowledge revisions, maps, private briefs and saved builds. Interrupted workflows retain checkpoints. Every project and every assistant on the machine sees the same collections. A project that already contains a .expertise-compiler/ folder keeps using it; ask “Where does Lectic store my knowledge?” to see which applies.

Architecture and remaining boundaries →

Capture now, use later

Save things as you meet them, with a reason if you have one, and sort them into collections later or never:

Save this architecture talk. Great on permission boundaries, but don't treat it as company policy.

Use my AI Architecture collection to review this design.

Saving stores exactly what you shared and your note, nothing more. Processing happens when a use needs it. YouTube links become English captions on request (through yt-dlp, which lectic setup offers to install); other links stay saved as links. Lectic does not fetch article bodies, parse PDFs, OCR images, scrape social platforms or transcribe audio, and an unavailable caption stays a visible gap rather than a made-up summary.

From a phone, a two-action Share Sheet Shortcut posts straight to your Lectic link (guide); a synced-folder Shortcut remains for phones that cannot reach it.

Capture contract, states and sync details →

Current status

Your knowledge, your server, any assistant. Lectic is a single-user server you run wherever you like: a laptop, a container, a home box. Your assistant does the reasoning; Lectic keeps the results evidence-linked, reusable and yours. Nothing leaves your machine except through the private link you choose to hand out.

Toward portable knowledge

One knowledge store reachable from a phone, ChatGPT, Claude, Gemini, Codex and Claude Code alike, with local storage as the offline/private mode rather than the only mode. In place: one home per user behind a storage seam built for object storage (design →); an MCP server over stdio and Streamable HTTP so any client operates the compiler through validated tools; lectic share, an always-on container and phone capture over one private link (guide →). Still ahead: a remote object store behind the seam, so several machines can share one home without one of them being the server.

Test the idea with us

The automated suite covers provenance, revisions, capture, discovery, builds and reuse across unrelated fixtures. Semantic fixture answers are authored test data; they are not evidence that the compiler outperforms ordinary chat.

We are testing with AI builders, consultants, creators and knowledge-heavy professionals. The study includes fair baseline comparisons, fresh-session reuse, source changes and refinement on unseen tasks.

Start with the concept-validation guide →

Documentation

Contributing

Useful contributions include reproducible failures, evidence-quality improvements and observations from real tasks. Follow the development guide and preserve the separation between source content, personal context, expertise and builds.

Run the existing suite from a checkout:

python -m unittest discover -s tests -v

Report an issue with a minimal, sanitized example. Keep private corpora and client work out of public reports.

License

MIT. Imported content retains its original ownership and licensing; a citation does not grant redistribution rights.