// install · custom
Custom
For the operator who works at the CLI and knows the agent makes mistakes but lacks the architecture. The same organs (identity, memory, skills, rules) laid out in `.claude/` files for your work. 3–7 days, flat from 1 500 PLN.
// what custom claude code is
I don't write the application for you. That would be a dev contract, not a KL install. I build the architecture you're missing: the same organs as in OpenClaw and Hermes (identity, memory, skills, rules), but laid out in `.claude/` files (settings, hooks, permissions) for an operator who works at the terminal. What I've built for myself, ported to your workflow. The Claude Code session ends; your setup stays and grows.
// what it's built from
What it's built from.
An agent isn't magic or "a model". It's the sum of its files. It starts every session by loading them, so it stays continuous even though it technically restarts from zero each time. These are its organs.
Identity: who it should be
Here we define who the agent is: tone, character, boundaries. For many that's a detail, it can simply be plain and impersonal. For some it isn't: my wife likes that her assistant is Dwight, who says "FACT" before answering a question. It can be your favourite fictional character. Identity also covers the model choice: the agent can run on a local LLM or on the best one available. Are you a fan of Gemini, Claude, or Codex? Any of them can be your agent. It's one file, you edit it yourself.
Memory: what it remembers
Default AI forgets everything after the session. Here it's different. The agent has a file structure it loads at the start of every conversation: company context, decisions, your preferences. And it grows it itself. Over time it records what you like about its work, what not to do, when to use which skill. After a week it knows more than at the start.
Tools and skills: what it can do
What the agent can actually execute: concrete procedures, integrations, actions. Each skill is a file with a prompt and guardrails. The agent knows when to run it and when to stop and ask a human. We add and refine skills as the scope of its work grows.
Rules: how it behaves
The system prompt: how it should act, what it never does, when it escalates to you instead of guessing. Your marketing team can review the tone, legal can review the guardrails. You edit it yourself, no ticket.
You change a file, and the agent works the new way from the next conversation. No training, no ticket. The speed of a change is the speed of editing a text file. More on how we build memory: why AI forgets and how to fix it.
// how custom uses this
Custom takes those organs and assembles them in your project's `.claude/` directory: settings and permissions (what the agent does on its own, what needs approval), hooks, skills for your typical tasks, prompts in your voice, a memory architecture that holds context without overload. No outside cloud, no new tool: it's your Claude Code, just laid out properly. And you extend it further.
// what it actually does for you
What we'll shape your skills for.
Skills for your real tasks: the ones you do often and want the agent to do well the first time. Examples:
Writing content in your voice
LinkedIn posts, X threads, service descriptions: a skill that knows your tone and your rules, not generic AI. You edit the voice file yourself when the voice shifts.
Pre-sale / decision research
Before a client call or a decision: a skill that gathers sources, rates confidence, pulls counterarguments, assembles a brief. With guardrails so it doesn't make things up.
Contract / document review
A skill that pulls parties, subject, money, term, penalties, risks (with paragraph numbers) and flags anything unusual. The human decides, the agent prepares the material.
Repetitive technical work
Whatever you do at the CLI over and over, generating reports, tidying data, prepping a deploy: packed as a skill with a prompt and guardrails, so the agent knows when to stop.
Crons, if you want them
You can add a schedule, a daily brief, change monitoring, just like in Hermes. It's your setup; you extend it both ways.
The common denominator: this should be a Claude Code you can rely on, with memory that grows from your feedback, and skills that know when not to guess.
// who it's for
Who it's for.
You use Claude Code or Codex, you have a feel for tools, but your setup is loose files, not a system you trust.
You know where quality drops. You don't know how to arrange memory, prompts and guardrails so it drops less often.
You're not looking for a provider on retainer. You want a foundation and the knowledge to build on it.
// what you get with the install
What you get with the install.
Discovery 60 min
Understanding your goals, workflow and where exactly quality drops. Without it the skills would be guesswork.
The first version of the `.claude/` files
settings, hooks, permissions (what the agent does on its own, what needs approval), memory with context, 3–5 skills for your tasks, prompts in your voice. First polish from me.
3–5 skills for your tasks
Concrete things you do often, writing in your brand voice, pre-sale research, contract review: packed as skills with prompts and guardrails.
Memory / context architecture
How to structure memory so the agent "remembers" the important things across sessions without overloading context with junk. The agent grows it further itself.
Walk-through on extending it yourself
A one-hour call: how to add a skill, fix memory, debug when something stops working. Plus stack documentation.
// how it looks
How it looks.
Discovery: where quality drops
You show me your workflow and the places where the agent fails. A starting point, not a feature catalogue.
I assemble the `.claude/` files
config, memory layout, prompts in your voice, skill skeletons for your tasks.
Skills for real tasks
Each skill tested on your data, with guardrails and 2–3 feedback iterations, not "one prompt solves everything".
Walk-through and documentation
A one-hour call on extending it + documentation. From there the agent learns from your feedback and you build on your own.
// what you provide
What you provide.
I can do a default setup for an operator in your industry, but Custom lives on what you tell me about your workflow. The more context (how you work, what you like, what not to do, where the agent fails), the fewer fixes later. The full custom we do together at the start or in the first update.
- Your time for discovery. I need to understand your workflow and where quality drops. I handle the rest.
- A Claude Pro subscription or an Anthropic API key.
- Mac or Linux with a working CLI environment.
// scope
Scope.
- The first version of the `.claude/` files (settings, hooks, permissions, memory, rules)
- 3–5 skills for specific tasks
- Prompts + voice training in your voice
- Memory / context architecture
- Walk-through + stack documentation
- Writing the full application for you (that's a dev contract, not a KL install)
- Production integrations with external APIs (quoted separately)
- Hosting / deployment
// timeline · effort · price
Timeline, effort, price.
3–7 working days
~8 hours of my work per install
from 1 500 PLN flat; the price is fixed in this phase (first-wave promo; reverts to 3 500–4 500 after the first case-study clients)
Optional 1 000 PLN/mo, first month free. Operators of this type usually skip the retainer; they debug themselves. Your call, zero pressure.
The LLM subscription or API key is on your side (ChatGPT Plus with OAuth ~$20/mo preferred: flat, no per-query burn; or an Anthropic/OpenAI/Gemini key). Contract disclaimer: token cost is yours.
// video
A walkthrough and demo of how it works
Coming soon: a clip showing what a laid-out `.claude/` setup looks like: skills, memory, guardrails. For now the fastest path is a free diagnostic call.
// faq
FAQ
Will you build me the application for this?
No. That would be a dev contract. I build the architecture of your Claude Code: config, skills, memory, prompts. A full production application is a separate conversation and a separate quote.
Why do I need this if I handle Claude Code myself?
If you handle it at the "I've got it laid out and it holds on its own" level, you don't need me, and that's fine (it's explicitly outside my offer). This is for the operator who feels the agent makes mistakes but doesn't know how to arrange memory, prompts and guardrails so it stops.
How is this different from OpenClaw or Hermes?
The same organs (identity, memory, skills), a different casing. OpenClaw lives in the team's channels, Hermes is a background worker. Custom is your own Claude Code laid out for a technical operator at the CLI. Want both? The Hybrid Agent Stack combines a ready runtime with a custom CLI.
Will guardrails really stop the agent from doing dumb things?
Guardrails and permissions in `.claude/` define what the agent does on its own and what needs your approval. The point isn't zero errors; it's a system where slip-ups get caught before they go further, like a reliable colleague who still has a process that catches mistakes.
Do I pay for tokens separately?
Yes. Your own Claude Pro subscription or Anthropic API key. Token cost is on your side, you keep your own billing and control.
// start
Where can Custom help you?
Free call, 30 min. We look at your workflow and the places where quality drops. I come back with a proposal for how to lay it out.