Operator tooling for Claude Code.
Clayworks LITE is the free MIT foundation. The paid bundle is the production-hardened operator system built on top of it.
Yes, for you: You're using Claude Code for real work. You've already hit the friction. You're comfortable in a shell and have opinions about your tooling. You want a sharper edge, not a wizard.
Probably not for you: You're just starting with Claude Code and want the simplest possible experience. Use CC stock for a few weeks first; come back when you feel the gaps.
Definitely not for you: You're looking for a no-code "AI assistant builder" or a low-effort productivity app. Clayworks is operator scaffolding for technical users.
LITE: the free foundation
LITE is the minimum competent baseline I use every day, distilled from the full operator system. MIT-licensed, seven components, intentionally minimal. Install in a fresh Claude Code workspace or merge it into an existing one.
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
/plugin marketplace add clayboicardi/clayworks-lite
/plugin install clayworks-lite@clayworks-litegit clone
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: production-hardened operator system
You can build all of this yourself from the LITE patterns. The bundle ships one version, hardened over months of daily use, with the rationale for every decision documented inline.
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 (Gemini CLI + local Ollama integrations with logging, sandboxing, fallback)
- 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
Join the waitlist
The bundle ships when it's ready. Drop your email and which tier you care about. You'll get a heads-up when it's available.
Waitlist form pending. I create the Tally form, drop in the formId, and this component renders the live embed. Until then this placeholder holds layout space so the rest of the page renders correctly.
Pricing
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.
LITE
The free foundation. Install via plugin marketplace or git clone. Use it commercially, modify it, redistribute it.
Get LITE on GitHub →Bundle
One-time purchase. Free updates through v1.x. The production-hardened operator system distilled from daily use.
Join the waitlist →Done-for-you services
If you'd rather have someone execute, these options are available on request. Open a GitHub issue (linked in Contact below) to start a conversation.
Focused sprint to get the bundle deployed and working in your existing setup.
End-to-end install plus customization to your specific stack and workflow.
Ongoing operator support: advisory, troubleshooting, configuration updates.
Who built this
I'm @clayboicardi on GitHub. Technical operator. I learned most of my stack autodidactically over the last several years. I built the internal operator system that Clayworks LITE and the bundle distill from over several years of daily Claude Code use.
I run this stack every day on my own machine. It's not a thought experiment. It's the system I actually use.
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.
Acknowledgments
The pattern of organizing Claude Code operations around persistent memory, structured hooks, and multi-AI orchestration didn't emerge in isolation. Tools and people whose work informed this kit:
Tooling
- Anthropic. Claude Code itself, plus the superpowers skill collection that anchors a lot of LITE's structural assumptions.
- Plastic Labs. Honcho, the user-modeling layer that taught me to separate facts about the project from facts about the user.
- Gentleman-Programming. Engram, the cross-model persistent memory plugin.
- nyldn. Octo multi-AI orchestration; the bundle's routing pattern compounds with it nicely.
Community
- awesome-claude-code curators. hesreallyhim, rohitg00, ComposioHQ. Maintained lists that map the CC plugin and skill ecosystem.
Contact
- Service inquiries. Open a GitHub issue at clayworks-lite/issues.
- Security disclosure. See SECURITY.md.
- Code of conduct. See CODE_OF_CONDUCT.md.