From Adoption to Craft

Token optimization for AI-assisted development workflows

Instructions
Prompt Files
Skills
Agent Prompts
Context Hygiene

Audience promise: leave with a practical playbook to get faster, better AI coding outcomes with less context waste.

Why This Talk Now

  • We are past adoption mode
  • The old question was: "Are people using it?"
  • The new question is: "Are we getting better at using it?"
  • Maturity means:
    • higher signal, lower noise
    • predictable speed and quality
    • repeatable team practices

This is craft work now, not feature novelty.

Session Flow (20 Minutes)

  1. Where tokens burn in daily development
  2. The three customization layers and when to use each
  3. Prompting and context habits that improve outcomes
  4. Tooling hygiene: MCP and interaction mode choice
  5. Team rollout plan to level up fast

Talk track: optimize for quality, speed, and context efficiency together.

Why Tokens Matter Even on Unlimited Plans

Concern Impact on your day
Response quality Bloated context dilutes useful signal
Speed Larger contexts usually increase latency
Context window limits Irrelevant tokens displace relevant ones
  • "Unlimited" does not remove latency and context constraints
  • Efficient context design improves both quality and pace

Where Daily Token Spend Actually Comes From

  • Always-on instructions
  • Open file and tab context
  • Chat history accumulation
  • Agent exploration and tool calls
  • Retrieved docs and workspace content
  • MCP tool descriptions and schemas

Fixed context costs compound across every interaction.

Use the Right Layer for the Right Job

Layer Loaded when Best use
Instructions Automatic Universal project rules
Prompt files You invoke Repeatable workflows
Skills AI decides Specialized procedures
  • Maturity pattern: remove rarely-needed detail from always-on instructions
  • Move specialized guidance to prompt files and skills

The Core Efficiency Move

Ask this every time:

"Does this need to be present on every interaction?"

  • If yes: keep in instructions
  • If manually triggered workflow: prompt file
  • If task-specific guidance the AI can detect: skill
Placement strategy Typical result
Everything in instructions High noise, slower focus
Scoped and layered context Cleaner signal, better outputs

Keep in instructions

  • Architecture constraints
  • Stack-specific conventions
  • Non-negotiable team rules

Cut from instructions

  • Generic coding advice
  • Rarely used procedures
  • Long examples for niche tasks

Link instead of inline

  • Point to docs so the agent reads them on demand
  • Use clear topic labels so retrieval is intentional

Scoped Instructions Beat Monolithic Rules

  • Path-specific instruction files load only when relevant
  • Example areas:
    • tests
    • api handlers
    • database code
  • Benefits:
    • less context noise
    • stronger local guidance
    • easier ownership by domain teams

One giant instruction file is usually an anti-pattern.

Prompting Agents Like an Engineer

High-efficiency prompt anatomy:

  • clear goal
  • explicit scope
  • explicit constraints
  • precise deliverable

Example structure:

Add JWT auth for /api/v2 routes.
- Use existing user model and password flow
- Return 401 with standard error format
- Do not modify frontend or existing tests

Common Prompting Mistakes

  • Vague asks that trigger broad exploration
  • Multi-topic prompts that should be separate tasks
  • Missing out-of-scope boundaries
  • Pasting large snippets instead of referencing files

Better practice:

  • break work into focused units
  • reference concrete files and patterns
  • define done criteria before execution

Context Hygiene Inside the IDE

  • Write clear signatures before function bodies
  • Use descriptive naming for free context
  • Keep relevant tabs open, close noisy tabs
  • Keep workspace clean:
    • exclude generated artifacts
    • remove abandoned files
    • maintain ignore rules

Your codebase quality is your model context quality.

MCP and Tool Context Discipline

  • Every connected tool adds context overhead
  • More tools is not automatically better

Good habits:

  • disconnect unused servers
  • scope tools per workflow
  • prefer focused toolsets for focused tasks

Result:

  • better tool selection behavior
  • lower context overhead
  • fewer accidental detours

Right-Size the Interaction Mode

Mode Cost profile Best for
Inline Lowest Local completions and known patterns
Chat Medium Targeted edits and explanation
Agent Highest Multi-file implementation and exploration
  • Do not use agent mode for a one-line fix
  • Use the lightest mode that can complete the task correctly

Team Metrics That Show Maturity

  • Time to useful response
  • First-pass acceptance rate
  • Rework rate after AI-generated changes
  • Context efficiency indicators (noise vs useful context)
  • Prompt-to-completion cycle time

Do not optimize raw usage. Optimize outcome quality and flow efficiency.

30-Day Team Upgrade Plan

Week 1

  • Audit and trim instruction files
  • Separate universal rules from specialized procedures

Week 2

  • Add scoped instructions by domain
  • Create prompt files for top repeat workflows

Week 3

  • Convert specialized procedures into skills
  • tighten agent prompt templates

Week 4

  • Review metrics, refine patterns, publish team playbook

Final Message

  • Adoption got us started
  • Optimization makes us better
  • Better context design improves quality, speed, and consistency
  • This is a craft discipline, not a one-time tuning exercise

The goal is simple: less noise, better engineering outcomes.

Q and A Prompts

  • Which always-on instruction is currently noise?
  • Which workflow should become a prompt file this week?
  • Which specialized process deserves a skill?
  • Where are we still using agent mode when chat or inline would be better?

Backup close: "Pick one workflow. Tighten context. Measure improvement. Repeat."