Claude doesn't know your business. Yet.

LITE: the free foundation

LITE is the free foundation. MIT-licensed, available on GitHub, installs in one command. It's the starting point if you want to see what Claude Code can do with the right configuration before paying anything.

What's in it

• CLAUDE.md starter template. An anonymized version of the CLAUDE.md I run in production, with structure preserved and contents replaced by example rules. Drop it in, customize per-section, ship. Section ordering encodes a specific philosophy.
• Multi-memory routing decision tree. A standalone skill that helps you decide which memory layer to use for a given fact. Engram for procedural decisions, Honcho for who-you-are, native MEMORY.md for project-specific. Routes to whichever layer you have.
• Nudge install pattern. A SQLite-backed reminder system that surfaces time-based pings via a UserPromptSubmit hook. "Stop me at 5pm." "Remind me about the standup at 9:55." Three small Python scripts plus the skill that drives them. Not flashy, genuinely useful.
• Hook scaffolding examples. A minimal .sh example for each Claude Code hook event (UserPromptSubmit, Stop, PreToolUse, SessionStart, SessionEnd, others). Each annotated with the event contract, JSON payload shape, and one common pattern.
• Heartbeat framework concept doc. A written explanation of the heartbeat pattern I use to keep my agent reflecting on its own state and surfacing decisions on a regular cadence. Concept only, not implementation. The full system ships in the paid bundle.
• Worked examples. Two complete LITE configurations (minimal + full) ready to adapt. Shows what the kit looks like assembled instead of as parts: settings.json for two adoption levels, customized hook scripts, and a sample CLAUDE.md.
• README + install scripts. The walkthrough you're reading on GitHub plus a Bash/PowerShell installer that drops the right files into the right places without clobbering anything. Idempotent. Includes verify and uninstall flags.

Install

/plugin marketplace add clayboicardi/clayworks-lite
/plugin install clayworks-lite@clayworks-lite

git clone https://github.com/clayboicardi/clayworks-lite.git
cd clayworks-lite
./install.sh           # macOS / Linux / Git Bash
.\install.ps1          # Windows PowerShell 5.1+

Full docs, source, and design rationale at github.com/clayboicardi/clayworks-lite.

The bundle: the system I actually run

You're not buying a tool to help you write code. You're buying a system that manages an AI developer. The CLI is the chat interface for the contractor — you give a brief, you evaluate the work, you adjust. If you've ever hired a contractor (a cleaning service, an accountant, an IT consultant), you already know the skill.

You can build all of this yourself from the LITE patterns. The bundle ships one hardened version, with the rationale for every decision documented inline. Hiring a developer to build an equivalent CC operator system runs into tens of thousands of dollars. Clayworks is a one-time purchase of mine for a fraction of that.

What's not in LITE

• Annotated production CLAUDE.md (every rule with rationale, not just structure)
• CC↔CC inter-session communication system (filesystem messaging + notification routing for parallel CC sessions)
• Full three-tier observability stack (per-prompt outcomes, end-of-session structure check, memory consolidation)
• Multi-AI bridges (multi-provider fan-out across Gemini, Codex, Cerebras, and local Ollama — with logging, sandboxing, fallback, and a Claude-synthesized merge of the responses)
• CC docs freshness gate (UserPromptSubmit hook that injects fresh local-mirror context so the model doesn't fall back to stale training data)
• Inbox watcher pattern (drop a markdown file in a folder, the agent picks it up on next session start)
• Multi-node sync docs (running CC across primary + secondary machines with consistent state)
• Morning briefing, evening consolidation, weekly review, and reflection beat templates
• Telegram integration (proactive notifications + remote control over your CC instance from your phone)
• settings.example.json with per-key rationale (the env vars, hooks, permissions, plugin set, and marketplaces I run in production)
• Plugin baseline doc (full 23-plugin operator stack with the why for each addition)
• Operating Claude Code at production quality (15–30 page written guide on the operator discipline that holds the system together)
• Install guide + troubleshooting field guide

Clayworks is primarily for internal tools, back-office automation, and work you already do. If you want to ship a side venture with the same tools, it works for that too.

Pricing

A Claude power-user workshop runs around $800. An AI workflow consultant charges $150 an hour. An AI agency engagement starts at $5,000. Clayworks is $49, one time.

LITE is free and stays free. The bundle is a one-time purchase with an early-adopter rate for the first 30 days. Free updates through v1.x.

One payment. No subscription. Uses your existing Claude Pro or Max plan.

Common questions

Why I built Clayworks

I built every component of Clayworks one piece at a time, for a live need in my own business. The CLAUDE.md template is the configuration I actually use. The hooks have run thousands of times. If Claude updates its behavior, I update the bundle.

Most similar systems are specialized tools, narrow and one-purpose, sometimes built as quick exposure grabs. Clayworks is the opposite. A plug-and-play system designed to be functional for virtually any use case, enhancing what you already do and unlocking what you've been meaning to build.

Who built this

I'm @clayboicardi on GitHub. I'm not a developer. Six months before launching Clayworks LITE, I didn't know what GitHub was. The system you're looking at is what let me ship real work anyway.

I run this stack every day on my own machine. It's not a thought experiment. It's the system I actually use to do work I would otherwise have to pay a developer thousands of dollars for.

Other public work

• HarmonoidWidget. Android home-screen widget for the Harmonoid music player. Kotlin, MediaSession integration.
• JAMZ. Fork of the Gramophone Android music player with custom branding and UI changes. Kotlin, Material Design.

Glossary

Every dotted-underlined term on this page links here. If a phrase didn't land in context, look it up. No need to memorize anything — the system is designed to compensate for what you don't know yet, while you stay in control of the work.

Claude Code

Claude Code is Anthropic's command-line tool. You install it once, then chat with Claude inside your terminal. Unlike a web chat, Claude Code can read files on your machine, edit them, and run shell commands you've authorized. It's the engine Clayworks builds operator scaffolding around.

MIT-licensed

MIT is one of the most permissive open-source licenses. If something is MIT-licensed, you can copy it, modify it, sell it, embed it in your own work — anything you want, as long as you keep the copyright line that names the original author. No money owed, no permission needed.

shell scripts

A shell script is a plain text file that contains commands your computer's terminal (the "shell") runs in order. Files ending in .sh are shell scripts. They automate sequences of steps you'd otherwise type by hand. The LITE installer (install.sh) is a shell script.

config files

Config files (short for "configuration") store the settings a program uses. When you install software, it often creates config files in standard locations. You can edit them with any text editor. Claude Code's main config files live in your home directory under ~/.claude/.

CLAUDE.md

CLAUDE.md is the rules-of-engagement document Claude Code reads at the start of every session. It can contain your identity, behavioral rules, project-specific context, anything you want Claude to consistently know. The LITE kit includes a starter template; the paid bundle includes the full production version with rationale for every rule.

hook

Hooks are Claude Code's extension mechanism. Specific moments in the session (like "user submitted a prompt" or "session is ending") are events you can hook into. You point a hook at a script; when the event fires, the script runs. The LITE kit ships annotated examples for all 8 hook events.

Engram

Engram (by Gentleman-Programming) is a Claude Code plugin that adds persistent memory. You tell Claude "remember this", Engram stores it locally, and the next session can recall it via search. Engram is free and runs entirely on your machine. The LITE memory-routing skill helps you decide what goes here vs other memory layers.

Honcho

Honcho (by Plastic Labs) is a Claude Code plugin focused on user modeling. While Engram remembers facts about your project, Honcho remembers facts about you. Over time it builds a profile of how you work and Claude can tailor its behavior. Honcho costs about $2-3/month after a $100 credit.

SQLite

SQLite is the most-used database in the world. It's not a service you run; it's just a single file format that programs read and write to. The LITE Nudge skill uses a SQLite file to store the reminders you set, because no setup means it works for anyone immediately.

JSON

JSON (JavaScript Object Notation) is a way of writing structured data in plain text. It's used everywhere modern software talks to itself: config files, API responses, the messages Claude Code's hooks pass back and forth. It's simple enough to read by eye and strict enough that programs don't get confused.

settings.json

settings.json is the single most important configuration file Claude Code reads. It controls which hooks are wired up, what commands the model is allowed to run, environment variables it has access to, and which plugins it loads. The LITE kit ships an example settings.json that shows a working hook composition you can adapt.

observability stack

An observability stack is the set of tools that surface what a software system is actually doing, so you can debug it without guessing. The paid Clayworks bundle ships a three-tier observability stack for Claude Code: per-prompt outcomes grading (was this answer good?), end-of-session structure check (did the system stay coherent?), and end-of-session memory consolidation (what should we remember from this session?).

Contact

• Service inquiries. Open a GitHub issue at clayworks-lite/issues.
• Security disclosure. See SECURITY.md.
• Code of conduct. See CODE_OF_CONDUCT.md.