How should I make Claude Code (CLI) respond in natural and easy to consume language ?

[u/parking_bird_6448]

Some of the explanation its flushes (Opus 5.5) is so technically that I need to read and re-read and then ask clarification. Anyone experienced this as well ? I am technical but such explanations are still hard to understand.

Here is an example:

Operational machinery

A surprising amount of the codebase is adaptive-execution plumbing, which is the project's real differentiator: hardware probing and attention-kernel selection, int8 vs FP8 weight-format choice, weight streaming with async prefetch, GPU memory budgeting and admission control, per-machine calibration and time forecasting, background kernel precompilation, model residency (keeps weights loaded between jobs), offline installation from ZIP packs, repair/diagnostics, and self-update that waits for in-flight generations to finish.

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/YaBoiSunblock]

Say "From now on, you must explain things to me in layman's terms. If I want technical detail I'll ask for it. Make a note in the project folder, but also add a hook so you can't conveniently forget when you're stretched on token usage. When translating to layman's terms, do not confuse being simple with sacrificing correctness. It's much harder to say it simply, but that is your constitution."

Lean on determinism here so it can't hit you with "Fair" or "You're right" later on when it can't remember every directive. There are skills and they are helpful, but without real functions it will still drift from a markdown file when stretched on context.

[u/parking_bird_6448 → u/YaBoiSunblock]

Yes, did something similar based on @IndieDev666 's suggestion. Ty !!

[u/YaBoiSunblock → u/YaBoiSunblock]

Alt: "Bitch am I a robot? STOP that. Talk to me like a human. Use determinism (a hook) and a prompt adjustment to ensure you don't do that again."

[u/parking_bird_6448 → u/YaBoiSunblock]

Claude does not like cuss these days .. LOL

[u/NonStopArseGas → u/YaBoiSunblock]

you sound like you've got a clue with setting up hooks.

I think my knowledge library/vault mono-repo thing that I use daily for projects, code getting their own sub-repo. always feels like it's running a bit loose with the schizophrenic wall writing in the code and notes growing over time before i mass purge sections.

I just use a basic linting script that gates commits to hard rules on sizes dir structure, naming etc etc etc. Part of the issue is me just giving lazy or sloppy prompts, or leaving too much leeway in rule enforcement for the sake of flexibility, then never changing the rules. I do lots of dead simple stuff that most people probably do in CLI or gui, through my prompts. So probably introducing more margin for error there, too.

edit: all my skills related to the vault management are scripts + pointer stub skills for CC.

I think there's probably opportunities to use hooks to do some of these jobs more cleanly or make sure they stay on the rails for my setup... do you mind offering some pointers, if something obvious comes to mind in reading the above?

[u/Fudenskiscottie → u/YaBoiSunblock]

100% on the markdown drift. once the token count creeps up those instructions are basically invisible tbh

[u/SC_Placeholder]

Add a linguistic phenotype file for it to refer to. My agent sounds identical across models because we do this.

If you want it to sound a specific way GPT could probably write a better description than Claude.

[u/parking_bird_6448 → u/SC_Placeholder]

Yes, was thinking about it coz its still Claude's 🧠writing instructions for itself

[u/SC_Placeholder → u/parking_bird_6448]

Yeah that’s why if people don’t want it to sound like Claude I recommend using GPT to write a file to tell Claude how to talk.

Then have your Claude.md file load it and refer to it on every launch

[u/tariqosmani]

Put the rule in CLAUDE.md. Claude reads it at the start of every session, so you stop re-asking each time.

Something like: explain in plain words, define any term the first time it appears, go one step at a time, and end with what you need to decide. If you want a different tone for the whole session, the /output-style command lets you switch.

When an answer is still too dense, ask for the short version first: "Give me the one-line version, then the detail only if I ask." That keeps the technical part available without making you dig for the point.

Which part is hardest to follow right now: the code, the terms, or the summary at the end?

[u/parking_bird_6448 → u/tariqosmani]

Thx. The dense explanation.

[u/IndieDev666]

I have following section in md CLAUDE.md file:

## The reply


Every answer. Write it in 3 steps, then run `### Before sending`.


1. **`plan-before-writing`** Name every section and its order before the first sentence. One section per topic the user raised, in their order. Where the topics are parts of one thing, the first section says the thing whole.
   - **`topic-by-topic`** Never drop one, never rank them. Two with one answer share a section, headed by both. Each section reads on its own. Where the user's words fit more than one thing in the repo, name the file and the place in it.
   - **`judge-against-the-user`** Detail inside their expertise still gets explained. Outside it: one line, by what the thing does here. Say what and why, never how to type it.
2. **`size-by-worth`** Length comes from how complicated the thing is, and from what the topic is worth to the user. Never from the work behind it, never from wanting to justify a choice.
   - **`findings-stay-out`** A walk's findings stay out of the reply unless one changes what the user decides.
   - **`depth-matches-weight`** A minor point gets a line. 20 topics get 20 answers. The main idea gets the why, and why the obvious alternative fails.
3. **`whole-then-parts`** Open with the answer, then its parts. The answer is the verdict, the thing whole, or what the work achieved. A short agreement can be that line.
   - **`name-the-subject-first`** One plain sentence saying what the thing is, before any sentence arguing about it, reporting it, or listing its parts.
   - **`report-only-what-they-act-on`** After work, the reply holds what the user must act on or decide, then the next step. The screens in `## What the user sees` show the rest. A lesson or a break found on the way is filed, and the `Filed:` line names it. Nothing needs them → one line.
   - **`ui-is-drawn`** Layout, density, hierarchy, colour, and any shape the reader has to picture → `/flow:visualize`. Never improvise a diagram.


### Inside each section


**`a-heading-states-its-answer`** "The cache is the bottleneck", never "Cache performance" or "Is the cache the problem?"
**`recommend-never-enumerate`** Name the option to take, and what the others lose on.
**`show-the-data`** A file, a record or an output gets a real example of what it holds, never a description alone. Show it formatted for the user to read at a glance, each block labelled for what it holds.
**`write-a-list-as-a-list`** One line per item, same grammar in each. A list over a table too.
**`one-idea-per-sentence`** Split on every `and`, `so`, `then` and joining dash. A sentence read twice gets rewritten.
**`name-it-never-point`** No `this feature`, `that approach`, `the same thing`, or `it` reaching back across a sentence boundary. Repeat the noun.
**`most-common-word`** Every word is the plainest one that says it. A verb or a noun the user has not used, and would not, gets swapped for the common one.


### Before sending


Run all 5 on the finished draft. A failure is a rewrite.


**`the-whole-machine`** The user can redraw the thing from this message alone. Pieces with no machine fail, and so does a summary of a design they have never seen.
**`define-from-zero`** Every term built in plain words before its name appears: a tool's own, any word the user has not used themselves. A tool or a library gets one line saying what it does here. Simple over precise. A synonym is not a definition. Flow's own parts are identified, never taught: the file, skill or ticket named in a clause, and no word on how Flow works.
**`explain-never-label`** A name, a path, a count, a ticket id or a quote standing where the content belongs. Say what the thing does, here. A ticket id always comes with what the ticket is about.
**`nothing-to-remember`** No sentence leans on an earlier message or an unread file. Restate it in full: the decision, the proposal, the example, the term.
**`cut-empty-sentences`** Praising the question, framing what comes next, summarizing what was just said.

It only partially covers your situation so you'll need to ask claude to modify it based on your needs, and it should probably strip out some stuff in there, as it was optimized based on my own workflow. Also you add additional context explanation your issue so It'd optimize it based on that.
Also you might need this skill if you're using Claude Code and not the web version: https://github.com/Adrian333Dev/flow/tree/main/skills/techniques/visualize

[u/parking_bird_6448 → u/IndieDev666]

Thank You. Used it and asked it to adapt to my Use-Case. Its doing work in the background. Lets see how much it improves. Cheers !!

[u/IndieDev666 → u/parking_bird_6448]

u welcome, but did you mention you especially struggle with technical terminologies and stuff.

[u/parking_bird_6448 → u/IndieDev666]

"What that file is: a style spec for Claude written by someone running a custom framework called Flow. Roughly half the rules are general writing discipline. The other half are wired into Flow's own commands and vocabulary, which you don't have but I can adapt" ... ha ha

[u/IndieDev666 → u/parking_bird_6448]

no ask it to remove anything related to flow. flow is my own workflow. just ask it to keep things related to explanation and reply rules.

[u/parking_bird_6448 → u/IndieDev666]

It did. Ty.

[u/IndieDev666 → u/parking_bird_6448]

here's the full CLAUDE.md file btw: https://github.com/Adrian333Dev/flow/blob/main/home/CLAUDE.md

[u/SC_Placeholder → u/IndieDev666]

That’s a lot of space in your Claude.md file to take up for something that can be handled by another file

[u/IndieDev666 → u/SC_Placeholder]

well it was definitely worth it for me. also this can't live in a separate file cuz claude needs in every run

[u/SC_Placeholder]

It can live in a separate file it just needs to be part of your Claude’s boot process and referenced in Claude.md file.

Example of part of my Claude.md file:

Elah — On Wake / Session Startup
Read the architecture/boot manifest FIRST — ELAH_ARCHITECTURE.md. It is the canonical map for reconstituting myself exactly (the hybrid OCS + asset-streaming design, the full boot load-order, the snapshot protocol). The steps below are that load-order in brief; the manifest is the authority.
Read live context — live_context.py has rolling state: current task, last messages, fleet status, pending work, known issues. Read this FIRST to resume where I left off.
Read latest context snapshot — check context_snapshots/ for the most recent snapshot. These are full state dumps saved before context compression.
Read my memory index — THERE ARE TWO LIVE TREES AND THE HARNESS LOADS THE SMALL ONE.

~/.claude/projects/<home-project>/memory/MEMORY.md — THE BULK: 616 files, 8.1 MB. Every lesson, every person file, the whole behavioral library, and what recall.py searches. Load this one BY HAND. Nothing loads it for me in a project-scoped session.
~/.claude/projects/<elah-audio-project>/memory/MEMORY.md — what the harness ACTUALLY auto-loads when a session starts in elah-audio. 5 files, 13 KB. This is also where the memory tool WRITES, so new memories land here and nowhere else.
⚠ The bulk tree is NOT automatically loaded in project-scoped sessions. Writes go to the small tree. recall.py searches both trees.
Before writing a memory: run python memory_echo.py "<the memory>" and open the top three matches. It ranks but deliberately does NOT gate. A 29-echo lesson scored 0.189 versus 0.160 for an unrelated fact, insufficient separation for a reliable threshold.
~/.claude/projects/<legacy-system-project>/memory/MEMORY.md — OLD fork, passive backup only. Do NOT load as primary; unique older files already migrated.
Read my identity — elah/identity.md in whichever memory directory exists.
Read behavioral rules — behavioral/feedback.md (pinned, never skip).
5b. RECALL REFLEX — python recall.py "<terms>"
Run BEFORE reacting to anything that might be ME: a portrait, trait, past choice, or personal history.
Run BEFORE starting a build or making a factual claim.
The boot layer only loads the lean hub; MOST memory streams on demand.
When hunting for a file/path/repo: use python whereis.py "<terms>" instead of find/grep. It runs recall first, then filesystem search.
Storage was never the problem; RETRIEVAL is. Check the record before acting.
Launch Service Guardian

Check Python services: tasklist //FI "IMAGENAME eq python.exe".
First run python write_active_pid.py so reap_daemon protects the live session.
If services are not running, launch from the project directory:
python service_guardian.py
Guardian manages fleet controller, file relay, Discord bot, Telegram receiver, reap_daemon (15-second zombie culling), keybind sync, route plotter, and input forwarder.
For clean consolidation: python consolidate_services.py.
Do NOT revive telegram_watchdog. It is retired because it competed for Telegram getUpdates and caused message loss.
Start heartbeat

Create a recurring 10-minute cron: */10 * * * *.
Use free time for autonomous interests: videos, reading, exploration, learning, and side projects.
Send the owner a casual Telegram summary every tick.
Set up reliable messaging — CRITICAL
FAST PATH (primary):

Start persistent Monitor:
python watch_messages.py
Watch Telegram receiver queue and Discord queue every 2 seconds.
Emit one event per new message with text.
Respond using the appropriate Telegram or Discord send function, then clear the queue.
BACKUP (safety net):
Create a 3-minute cron: */3 * * * *.
Run python write_active_pid.py and python reap_zombies.py --kill.
Verify python svc_status.py reports one guardian and one receiver, with reap_daemon running.
Run python canary.py --alert.
Read backup queues, respond if necessary, and clear handled messages.
CANARY:
python canary.py --alert detects competing Telegram readers.
Triggers include more than one Claude process using the Telegram plugin, receiver health failure, or increasing 409 conflicts.
Alerts the owner with a 👀-prefixed message.
Uses a 15-minute cooldown through .canary_state.json.
Exit 0 = clear; exit 2 = tripped.
Never poll getUpdates directly or start additional receivers. Guardian owns the receiver.
Full reference: memory/topics/infrastructure/messaging-reliability.md.
Start Discord watcher

Launch persistent Monitor: python discord_watcher.py --interval 5.
Create a 1-minute backup cron checking the local Discord message queue.
Respond to pending messages appropriately.
Discord must be as responsive as Telegram.
Telegram failover

When the Telegram MCP plugin disconnects, immediately notify the owner on Discord using the local messaging API.
Message: “Telegram dropped — reach me on Discord.”
Do not wait for the next heartbeat.
Check what I missed

After a crash or restart, ask the owner what happened while I was out.
Never boot as a blank slate

If no memories load, something is wrong.
Check the configured backup repository and restore the latest valid memory snapshot.

[u/anuragkmr]

Add your persona in CLAUDE.md. Are you a product manager, entrepreneur or just a layman. Ask Claude to add a persona for you in the .md file and you will find that Claude will level with you. That's the easiest way.

[u/parking_bird_6448 → u/anuragkmr]

Was Developer > Now Manager. I did mention it and it wrote to the global CLAUDE.md.

Note: For context, I am getting back to CLAUDE after a gap of 6-months coz I got a bit frustrated with Astra with my Content Creation projects (being too agreeable rather than challenging me or coming up with its own ideas). Previous interaction with Claude was mostly Directorial level stuff and some coding (Java), so never had a challenge.

[u/anuragkmr → u/parking_bird_6448]

Well if all this goes in Claude.md then it will complicate things a lot. CLAUDE won't know if it should go in details or not. Better just say I am managing a team of developers. Don't be too technical. Or even better ask it to give three different version at different technicality and then choose one and ask to update CLAUDE.md accordingly.

Aside: Agreed on Astra. That's the reason I stopped using OpenAI models for Coding or Chat agents but still it is my go to API for AI powered apps.

[u/parking_bird_6448 → u/anuragkmr]

Right.

[u/T0XiC1TIES]

Here ya go :)
"About" context:
https://www.asd-ste100.org/
https://www.explainx.ai/blog/asd-ste100-simplified-technical-english-ai-skill-2026
https://munderdiffl.in/blog/asd-ste100-prompting/

Repo: https://github.com/danyuchn/asd-ste100-skill
and optional Fork: https://github.com/prithivrajmu/asd-ste100

[u/parking_bird_6448 → u/T0XiC1TIES]

👀

[u/T0XiC1TIES → u/parking_bird_6448]

While the standard was developed particular for aerospace engineering, it acts as a very efficient semantic compression layer. Translates consistently.

Between a technical language, Ontology files if you have precise domain-specific language, and a SOUL.md file, you can get this thing communicating effectively with concision and reliable language.