Links to Improve LLM Experience

This is a note to self for links which can improve day to day LLM coding agent experience.

The common theme in all of these links is simple: keep the context clean, keep the instructions short, and use the right model for the right job.

Optimize Your Context Files

• 12 Ways to Cut Token Consumption in Claude Code

  This is a very useful overview of where Claude Code tokens go. The article explains that a Claude Code session can start with a large hidden baseline from system prompts, memory files, CLAUDE.md, MCP schemas, and skills. It recommends trimming CLAUDE.md to only the things Claude cannot infer from the code, using .claudeignore together with permissions.deny, filtering noisy logs, and moving specialized rules into path-scoped rules or skills.

• The CLAUDE.md Memory System - Tutorial

  This tutorial explains how Claude Code memory works. There are different memory layers: global ~/.claude/CLAUDE.md, project-level CLAUDE.md, and modular .claude/rules/*.md files. The most important point for me is that memory files are injected into context, so they should be short, structured, and specific.

• Instagram: Claude Code 5-layer agent architecture

  This post describes Claude Code as a 5-layer agent system: CLAUDE.md, skills, hooks, subagents, and plugins. I like this framing because it makes Claude Code feel less like just a prompt box and more like a small programmable environment. The useful reminder is that CLAUDE.md is only one layer; not every instruction belongs there.

Control Output Verbosity

• claude-token-efficient

  This repository provides a small CLAUDE.md focused on making Claude responses shorter and more direct. The main rule is something like: read files first, write the complete solution, test once, and avoid over-engineering. The README also has an honest warning: instruction files add input tokens on every turn, so this helps most when the workflow produces lots of output.

• Instagram: 5 hidden Claude Code commands

  This short post is about hidden Claude Code commands. The page preview does not expose all command details, but it is still a good reminder to learn the command layer instead of repeatedly typing long prompts. Commands like /context, /compact, /clear, /model, and /memory can make sessions easier to control.

• Claude Code burns context faster than you expect

  LinkedIn hides most of this article behind sign in, but the title itself points to the same practical lesson: context grows faster than expected. Long sessions, large diffs, repeated tool output, and copied files can make every next message more expensive.

Define Thinking Effort

• Anthropic Docs: Effort

  The effort parameter controls how many tokens Claude spends while responding. medium is described as a balanced option for agentic work where speed, cost, and performance all matter. low is useful for simple or high-volume tasks. The important detail is that effort affects tool use and reasoning, not just visible response length.

• YouTube Short about Claude effort

  The page was not readable without YouTube access, but I am keeping the link here because it was part of my original list around tuning Claude’s effort level. For the actual reference, the Anthropic docs above are the source I would trust.

Surgical Tooling Over Full-File Reads

• Token Efficiency Optimizer

  This skill focuses on reducing token waste while working with large codebases. It recommends using grep, code search, and partial file reads before loading full files. This matches the practical workflow I want: search first, read only the relevant section, then edit the smallest possible surface.

• 10 Tips to Stop Burning Your Tokens in Claude Code

  This article explains why long Claude Code sessions get expensive: every turn resends conversation history, tool results, and files that were pulled into context. Useful reminders from it: use /context, compact at phase boundaries, avoid pasting whole files, write specific prompts, and remove MCP servers you are not using.

• YouTube video about Claude Code token efficiency

  YouTube did not expose useful metadata for this link, but I am keeping it with the context optimization links. The related idea is to avoid feeding the agent folders like node_modules, build output, generated files, and environment files.

Prune MCP Servers

• 10 Tips to Stop Burning Your Tokens in Claude Code

  The MCP section is worth calling out separately. Every connected MCP server can add tool definitions and schemas to the session. If a server is not needed for the current task, it is better to disable it and keep the tool surface smaller.

Smart Model Routing

• Claude Code Pricing: Optimize Your Token Usage & Costs

  This guide explains model routing and cost control. The idea is to use stronger models for planning, architecture, or hard debugging, and cheaper models for routine implementation. It also emphasizes prompt-cache discipline: repeated work should reuse context instead of spawning fresh sessions which pay the setup cost again.

• Claude Code vs Cursor vs OpenAI Codex: Which AI coding tool should you use in 2026?

  This article compares different AI coding tools and makes a useful model-choice point: use stronger models for thinking and planning, then use cheaper or faster models for execution. I would not treat every number in comparison posts as universal, but the mental model is useful.

Skills

• Skills For Engineers

  This repository by Matt Pocock contains agent skills he uses for real engineering work. The main idea is that skills should be small, composable, and easy to adapt instead of trying to own the whole process. I like this because it keeps the agent useful without hiding the work behind a giant framework.

  The skills are organized around common agent failure modes:

  • /grill-me and /grill-with-docs help the agent ask detailed questions before building, so the user and agent agree on what needs to be done.
  • /grill-with-docs also helps build shared language, update CONTEXT.md, and capture important decisions in ADRs. This can reduce verbosity because the agent can use project terms instead of explaining around them.
  • /tdd pushes the agent into a red-green-refactor loop, which gives it feedback from tests instead of letting it guess.
  • /diagnosing-bugs provides a disciplined debugging loop: reproduce the bug, minimize it, form a hypothesis, instrument, fix, and add a regression test.
  • /improve-codebase-architecture scans for places where the codebase can be deepened, meaning more behavior behind a smaller and cleaner interface.
  • /handoff turns the current conversation into a handoff document so another agent, or a later session, can continue without carrying the whole chat history.

  The installation section mentions two ways to use them: install the Claude Code plugin as a managed read-only bundle, or use skills.sh to copy editable skill files into your project. The important warning is to pick one approach, otherwise the same skills can be installed twice.

  One small trick for the /code-review skill is to write project-specific review rules into a standards file:

  echo "Tautological tests considered harmful." >> CODING_STANDARDS.md

  From then on, /code-review can pick this up as part of the repo’s coding standards. This is useful because the review skill should not only inspect whether the code works, but also whether the tests are meaningful. A tautological test can make coverage look good while testing the implementation against itself.

• Skills For Designers and Engineers

  This repository by Emil Kowalski focuses on helping agents build better interfaces. The useful idea here is that agents usually do not have strong taste by default. They can pick the wrong easing, use a border where a subtle shadow would feel better, or animate properties which should not be animated. Small UI decisions compound quickly.

  The skills capture design and animation judgment as reusable instructions:

  • emil-design-eng is the main design and animation skill.
  • animate helps build animations with the right curve, duration, and animated properties.
  • animate-expo applies similar animation guidance to React Native and Expo.
  • review-animations reviews animations against stricter rules.
  • improve-animations audits animations in a codebase and returns prioritized improvement plans.
  • find-animation-opportunities looks for places where motion would actually help, and also says what should not be animated.
  • animation-vocabulary helps describe animation intent with better words.
  • pick-ui-library helps the agent choose trusted UI libraries instead of hand-rolling everything.

  The install command is:

  npx skills@latest add emilkowalski/skills

  This is a good example of using domain expertise as an agent skill. The model still writes the code, but the skill gives it better taste and better constraints.

Compression Tools

• Caveman

  Caveman is a tool and skill for making agents use fewer tokens. The small version changes the response style so the agent says less while keeping code, file paths, commands, and errors intact. The larger proxy compresses what the agent reads, such as logs and structured data. The README is also honest that the skill itself costs input tokens, so it works best when the output savings are larger than the instruction overhead.

Code Quality Guardrails

• interlinked-cli

  Interlinked is a local guard layer for AI coding agents. It sits between the agent and the system, evaluates tool calls with deterministic rules, blocks dangerous actions, and keeps a local activity log. The part I find useful is the mindset: AI-written code should be checked by measurable gates, not vibes.

  How to clean up AI slop in a codebase:

  • Cyclomatic Complexity: < 22
  • Cognitive Complexity: < 22
  • Halstead Difficulty: < 80
  • Lines of Code per File: < 500
  • Test Coverage: 100%
  • CRAP: < 25
  • Surviving mutants: 0
  • Dead code: 0
  • Redundant code: 0
  • any or unknown types: 0

  This checklist is aggressive, but that is the point. If AI is generating code quickly, then the quality bar has to become more explicit. Complexity, mutation testing, dead code, redundant code, and weak TypeScript types are all places where generated code can look fine while quietly becoming hard to maintain.

Technical Writing

• Use ASD-STE100 Simplified Technical English as a writing constraint.

  A useful way to make LLM-generated technical documentation sound less like generic AI text is to give it a stricter writing standard. ASD-STE100 Simplified Technical English is designed for clear technical communication. Asking the model to follow it nudges the output toward short sentences, precise words, active voice, and fewer vague phrases.

  Example prompt:

  Rewrite this documentation using ASD-STE100 Simplified Technical English.
  Prefer short sentences, concrete verbs, and one instruction per sentence.
  Remove marketing language and vague claims.

Building APIs from Network Traces

• Anais Betts on using HAR files to make APIs and MCP servers

  This is not exactly about token efficiency, but it is a useful LLM workflow. The idea is to let the browser show the real network contract of a website, then give those traces to an agent so it can build a small TypeScript API client or MCP server.

  The rough workflow:

  1. Open the website.
  2. Open DevTools, go to the Network tab, and enable Keep log.
  3. Log out and log back in so the auth flow is captured.
  4. Visit the pages you want data from.
  5. In DevTools, right-click a request and use Copy all as HAR.
  6. Save the HAR output into a file.
  7. Also use Copy all as fetch and save that output too.
  8. Put those files in an empty Bun project.
  9. In Plan Mode, ask the model to read the traces and create a TypeScript API client and MCP server.

  The follow-up discussion has two important caveats. First, HAR files can contain cookies, tokens, and expiring headers, so they should be treated like secrets. Do not commit them. Strip credentials before sharing them with anyone. Second, a server generated from one logged-in trace might break when tokens rotate. The agent needs to understand refresh tokens, session cookies, pagination, and README instructions if the result is supposed to be generally usable by other people.

Summary

The pattern I want to remember:

• Keep CLAUDE.md short.
• Use .claudeignore and permission rules for files the agent should not read.
• Prefer search and partial reads over dumping whole files into context.
• Turn off MCP servers which are not needed.
• Use concise standing instructions, but do not make the instruction file huge.
• Use medium or low effort when the task does not need deep reasoning.
• Use expensive models for judgment, cheaper models for routine execution.
• Use skills for repeatable workflows instead of writing the same long prompt every time.
• Put project-specific review rules in files like CODING_STANDARDS.md so review skills can reuse them.
• Add measurable quality gates so AI-generated code cannot quietly become messy.
• Use a clear writing standard like ASD-STE100 when asking LLMs to write technical docs.
• Network traces can help an agent build API clients or MCP servers, but HAR files must be handled like secrets.
• Compact or clear sessions before old context becomes noise.