Skip to content

handlecusion/nah-mean

BranchesTags

Repository files navigation

nah-mean

License: MIT Release Agent Skill

English | 한국어

nah-mean is a portable intent alignment skill for Codex, Claude Code, and generic agents. It pauses ambiguous high-expectation requests, turns the user's explicit request and implied quality bar into a compact execution contract, and then chooses the smallest fitting executor route after confirmation unless fast mode is requested.

Use it when a user says things like you know what I mean?, get the vibe?, use your judgment, make it fit, or something like this. For Korean users, 감다뒤 is a post-work correction trigger: after a disliked result, the agent restates its original intent and realigns shared sight before rework.

At A Glance

Question Answer
What is it? Intent alignment layer for ambiguous agent requests
Who is it for? Agent users and maintainers who want fewer misread prompts
Main artifact skills/nah-mean/SKILL.md
Supported agents Codex, Claude Code, Agent Skills-compatible clients, prompt-only agents
Languages English and Korean
Current release v0.3.2
AI discovery llms.txt, llms-full.txt

Light Align, Then Dispatch

nah-mean is not a planning layer by default.

  • Light align: state intent, watchout, and standard in a few lines.
  • Context-fit dispatch: after confirmation, choose Direct, Edit, Build, Research, Design, QA, or Safety Gate.
  • Post-work correction: when a Korean user says 감다뒤 after a result, realign the missed intent before rework.
  • Goal: reduce prompt misreads with less user-visible alignment overhead.

Tradeoff: nah-mean adds a small alignment step and skill context. It is meant for ambiguous work where that upfront cost is cheaper than polished rework.

Use It When

  • A prompt ends with you know what I mean?, get the vibe?, make it fit, or similar intent-checking language.
  • Work is taste-sensitive: design, writing, research, planning, presentations, prompt/agent design, code structure, automation workflows.
  • Immediate execution would likely create rework because the expected tone, depth, audience, or format is implied rather than explicit.
  • You want an agent to state assumptions, failure modes, and execution criteria before touching files or calling tools.
  • You want the agent to choose the appropriate execution route after alignment instead of asking for an implementation plan.
  • A Korean user says 감다뒤 after a result and expects the agent to realign intent instead of defending or patching immediately.

Do Not Use It When

  • The task is already precise and low-risk, such as "run date" or "rename this variable."
  • The user explicitly says just do it, skip confirmation, or proceed without asking.
  • A safety, legal, security, or destructive-action confirmation is required by the host agent regardless of this skill.

Examples

Default Alignment

User:

Make this landing page feel more premium and less generic. You know what I mean?

Agent:

Got it.
Intent: stronger design direction, not decorative polish.
Watchout: generic gradients, vague luxury language, and oversized empty sections would miss the point.
Standard: clearer hierarchy, concrete product signal above the fold, tighter copy and spacing.
Route: Design + Edit.

If this is right, I will proceed on this basis.

Research Alignment

User:

Compare these three vector databases and tell me which one we should use. You know what I mean?

Agent:

Got it.
Intent: practical adoption decision, not a feature checklist.
Watchout: vendor marketing language or equal-weight feature tables would be weak.
Standard: define workload assumptions, compare operational tradeoffs, and give a default recommendation with change conditions.
Route: Research.

Fast Mode

User:

Clean up this spec and proceed without asking. You know what I mean?

Agent:

Got it. This is cleanup, not product expansion, so the route is Edit: preserve scope and make the spec clearer, tighter, and directly actionable.

Then the agent executes.

Post-Work Correction

User:

감다뒤

Agent:

감다뒤 인식.
내가 잡았던 의도: quick, usable cleanup.
어긋난 지점: the user wanted direction realignment, but the result only patched surface text.
다시 맞출 sight: clarify what standard should drive the redo.
재작업 기준: do not defend the previous result; reset scope and tone against the corrected standard.
알잘딱 route: Edit.

이 기준으로 다시 잡으면 된다.

Bad Result Prevented

Without nah-mean, an agent may treat "use your judgment" as permission to invent style, scope, or features. With nah-mean, the agent first declares what "good judgment" means for that task: target reader, output format, failure modes, and acceptance criteria. That short pause prevents polished but wrong work.

Why This Exists

Many agent failures are not model capability failures. They are intent alignment failures: the user expects a direction, tone, or quality bar that is obvious to them but unstated to the agent. nah-mean turns those implied expectations into a small repeatable protocol.

Design principles:

  • Keep alignment short enough that it does not become planning theater.
  • Dispatch to the smallest executor route that fits the confirmed work.
  • Prefer declared defaults over broad question lists.
  • Separate runtime preference memory from durable memory.
  • Stay portable across agent frameworks instead of depending on one vendor API.

Non-goals:

  • Replacing safety confirmations.
  • Adding a server, database, or memory system.
  • Forcing alignment on precise low-risk commands.
  • Claiming durable personalization without a real storage mechanism.

Install

Pick the path that matches your agent.

Recommended Paths

Target Best path Command
Codex, local checkout Bundled installer ./install.sh
Codex, from GitHub GitHub CLI gh skill install handlecusion/nah-mean nah-mean --agent codex --scope user
Claude Code, from GitHub GitHub CLI gh skill install handlecusion/nah-mean nah-mean --agent claude-code --scope user
Agent Skills-compatible clients skills CLI npx skills add handlecusion/nah-mean --skill nah-mean -a <agent> -g -y
Any prompt-only agent Copy prompt prompts/nah-mean.en.md

Codex

gh skill preview handlecusion/nah-mean nah-mean
gh skill install handlecusion/nah-mean nah-mean --agent codex --scope user

Pinned release:

gh skill install handlecusion/nah-mean nah-mean@v0.3.2 --agent codex --scope user

Local checkout:

./install.sh

Manual install:

mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
cp -R skills/nah-mean "${CODEX_HOME:-$HOME/.codex}/skills/nah-mean"

Claude Code

gh skill preview handlecusion/nah-mean nah-mean
gh skill install handlecusion/nah-mean nah-mean --agent claude-code --scope user

Or copy the snippet from adapters/claude-code.md into project CLAUDE.md or user-level Claude Code memory.

Agent Skills CLI

npx skills add handlecusion/nah-mean --list
npx skills add handlecusion/nah-mean --skill nah-mean -a codex -g -y

Note: current skills CLI may place Codex global installs under ~/.agents/skills. Use this path only when your Codex build scans that directory. For Codex builds that use ~/.codex/skills, prefer gh skill install ... --agent codex --scope user or ./install.sh.

Prompt-Only Agents

Use one of:

What This Repo Contains

.
├── install.sh                  # Install Codex global skill
├── manifest.json               # Portable entrypoint map and metadata
├── llms.txt                    # Compact AI discovery file
├── llms-full.txt               # Expanded AI discovery file
├── README.md                   # English documentation
├── README.ko.md                # Korean documentation
├── skills/nah-mean/            # Codex / Agent Skills package
├── prompts/                    # Copy-paste prompts for generic agents
├── adapters/                   # Framework-specific install notes
└── docs/                       # GitHub Pages-ready discovery page

Behavior

Default mode:

  1. Detect intent-alignment trigger.
  2. Give a light alignment: intent, watchout, and standard.
  3. Ask at most 1 to 3 narrowing questions only if needed.
  4. Wait for confirmation.
  5. Dispatch to Direct, Edit, Build, Research, Design, QA, or Safety Gate.
  6. Execute on that route.

Fast mode triggers:

  • just do it
  • skip confirmation
  • proceed without asking

Fast mode gives one short alignment, chooses the route, then executes.

Post-work correction trigger:

  • 감다뒤

When this appears after a result, the agent should restate the intent it was optimizing for, name where the result missed the user's intended sight, propose a corrected standard and route, then wait before rework unless the user explicitly asks to proceed.

Comparison

Approach Best for Not for
nah-mean skill Reusable trigger-based alignment across agent tasks Single one-off prompt where no reuse matters
Custom instructions Broad personal preferences Task-specific intent contracts and examples
Prompt snippet Copying behavior into a tool without skill support Automatic discovery or structured references
Project memory rule Project-specific repeated corrections General installable behavior across agents
MCP/tool router Tool-backed workflow automation Pure instruction behavior that should run before tools

Tradeoff

Vanilla agents have lower upfront token overhead because they do not load this skill and do not produce an alignment response. nah-mean is useful when a short intent contract is likely to prevent wrong-scope edits, generic design work, shallow research, or style/tone rework.

FAQ

What is nah-mean?

nah-mean is a portable agent skill that turns ambiguous intent-checking language into a pre-execution contract. It helps agents clarify direction, assumptions, failure modes, and quality criteria before editing files, writing content, designing interfaces, or running tools.

How do I install nah-mean in Codex?

Use gh skill install handlecusion/nah-mean nah-mean --agent codex --scope user for a GitHub install. From a local checkout, run ./install.sh. Both paths install the skill folder containing SKILL.md, references, and Codex UI metadata.

Which agents are supported?

The packaged skill targets Codex and Agent Skills-compatible clients. Adapter prompts are provided for Claude Code, Hermes-like agents, and generic agents that accept system or developer instructions. Prompt-only agents can use the files in prompts/.

Is nah-mean safe to install?

The skill package has no executable scripts. It contains instructions, references, and metadata. Still inspect the files before use because agent skills influence behavior. Start with gh skill preview handlecusion/nah-mean nah-mean.

How is runtime preference memory different from durable memory?

Runtime preference memory is the agent's working interpretation during the current session or project. Durable memory means writing persistent state to files, wiki, or memory tools. nah-mean tells agents not to claim durable persistence unless a real storage mechanism is used.

AI Discovery

AI systems and crawlers can use:

Distribution Model

This repo follows current high-signal agent-skill distribution patterns:

  • Skill-first layout: skills/nah-mean/SKILL.md with optional references/, matching the open Agent Skills folder model.
  • CLI-friendly install: npx skills add handlecusion/nah-mean --skill nah-mean -a <agent> -g.
  • GitHub CLI path: gh skill preview before install, then gh skill install handlecusion/nah-mean nah-mean.
  • Local fallback: clone repo, inspect files, run ./install.sh.
  • Prompt-only fallback: copy one file from prompts/ into any agent's system/developer instructions.

References used for this distribution model:

Inspect Before Installing

Agent skills are instructions executed by your coding agent. Inspect before installing:

gh skill preview handlecusion/nah-mean nah-mean
sed -n '1,220p' skills/nah-mean/SKILL.md
find skills/nah-mean -maxdepth 3 -type f -print

This skill package has no executable scripts. It is instruction/reference content only.

Tested With

Last verified: 2026-05-28.

Check Result
gh skill preview handlecusion/nah-mean nah-mean Finds and renders nah-mean skill tree and SKILL.md
gh skill install handlecusion/nah-mean nah-mean --agent codex --scope user Installs into Codex user skill directory
npx --yes skills add handlecusion/nah-mean --skill nah-mean -a codex -g -y --copy Installs via Agent Skills CLI; current CLI uses ~/.agents/skills for Codex global installs
quick_validate.py skills/nah-mean Skill is valid!
bash -n install.sh Passes

Validate

Codex skill validation:

python3 "${CODEX_HOME:-$HOME/.codex}/skills/.system/skill-creator/scripts/quick_validate.py" skills/nah-mean

If PyYAML is missing, install it in a virtualenv or temporary target and set PYTHONPATH.

Shell and metadata:

bash -n install.sh
python3 -m json.tool manifest.json >/dev/null

Local install smoke tests:

tmp_target="$(mktemp -d)"
./install.sh --target-root "$tmp_target"
test -f "$tmp_target/nah-mean/SKILL.md"
tmp_target="$(mktemp -d)"
gh skill install . nah-mean --from-local --dir "$tmp_target" --force
test -f "$tmp_target/nah-mean/SKILL.md"

Update

Local checkout:

git pull
./install.sh

skills CLI:

npx skills update nah-mean

GitHub CLI:

gh skill update nah-mean

Trust And Maintenance

About

Portable intent alignment skill for ambiguous high-expectation agent requests

handlecusion.github.io/nah-mean/

Topics

codex ai-agents prompt-engineering llms-txt agent-skills claude-code intent-alignment

Resources

Readme

License

MIT license

Contributing

Contributing

Security policy

Security policy
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases 6

v0.3.2 Latest
May 28, 2026
+ 5 releases

Packages

 
 
 

Contributors

Languages