AI Productivity: Why Claude Code Sits at the Center of My Dev Workflow
Claude Code has become an agent orchestration runtime with subagents, skills, MCP, and hooks. Early-2026 trends from a solo developer using it daily.
Joohwan Yu · Founder, Full Stack Developer
Toris · Published
Contents
Q. How far has Claude Code come in 2026? It has gone beyond a plain coding chatbot and become an agent orchestration runtime that extends through subagents, skills, MCP, and hooks.
Toris (토리스) is a one-person studio where the founder is also the developer, and Claude Code is the tool at the center of our development workflow. How mature each extension axis is decides what we hand to the agent and what a human keeps, so for us these trends are not tech news. They are material for operational decisions that drive development speed and cost.
When Claude Code first came out, it looked like “a coding chatbot that runs in the terminal.” Looking at it in early 2026, it is no longer a chatbot. It is closer to a single agent runtime that reads and writes the file system, runs commands, runs several subagents in parallel, plugs in external tools through MCP, and applies deterministic automation through hooks.
This post is not marketing copy. It is a rundown, from the point of view of a developer who commits with it every day, of where Claude Code is now and where it is heading. Rather than listing features, I try to be honest about “when it shines and when it wastes your time.”
What Claude Code Is: A Redefinition
Claude Code is an agentic coding CLI made by Anthropic. Two things are at its core.
- Agent loop: Given your goal, it searches and reads files on its own, edits code, runs tests, looks at the results, and fixes things again. The default is not a single response but a loop that “repeats until it works.”
- Local first: It works in your real repo, your real shell, and your real environment. It does not copy your code into a cloud sandbox. It touches the working directory on your machine directly.
The layers added over the past year (subagents, skills, MCP, hooks, plan mode, background agents) are the real story here.
Subagents: Splitting Context and Working in Parallel
The change you feel most is subagents. Instead of the main agent cramming everything into its own context window, it delegates specific tasks to child agents that each have their own context.
Why it matters:
- Avoids context pollution: An exploration task like “dig through these 20 files and find where the auth logic is” eats a huge number of tokens. If you hand it to a subagent, the subagent can read the whole pile of files and still return only the conclusion to the main agent. The main context stays clean.
- Parallelism: Tasks that don’t depend on each other, for example “frontend refactoring” and “writing tests,” can be handed to different subagents at the same time.
- Role separation: You define review-only, security-check-only, and exploration-only agents in
.claude/agents/and call them when needed.
Defining a custom agent for a project takes a single Markdown file.
---
name: security-reviewer
description: Finds auth bypasses, secret exposure, and injection in PR diffs
model: opus
tools: [Read, Grep, Bash]
---
You are a senior security engineer. Review only the changed code,
and report only vulnerabilities you are highly confident about.
Include the file path, line, and a reproduction scenario.
Practical tip: subagents are best for work that “reads, summarizes, and brings back only the conclusion.” For work where subagents have to exchange state closely with one another, you only add overhead. Use them for fan-out exploration and review, not for tight collaboration.
Toris has also been shaping its workflow so that exploration and review work goes down to subagents. In a one-person studio, the main context is the founder’s flow of work, so keeping it clean is itself productivity.
Skills: Reusable Capability Packages
Skills are the axis that changed the Claude Code ecosystem the most in 2026. A skill is, in a word, “a bundle of abilities that loads only when needed.” It packages instructions (Markdown), scripts, and reference material into one directory.
The core mechanism is progressive disclosure.
- Normally only the skill’s name and a one-line description sit in the model’s context.
- The full instruction body loads only when the user’s request matches that skill.
- Heavy reference files and executable scripts are read only when actually needed.
Because of this, the context doesn’t blow up even with dozens of skills installed. If you harden repetitive work such as “make a PDF,” “design review,” or “a specific in-house deploy procedure” into a skill, you don’t have to explain it in a prompt each time. It fires on its own when the trigger condition matches.
If MCP is connecting external tools and data, skills are codifying procedures and know-how. The two complement each other rather than compete.
MCP: A Standard for Connecting Tools and Data
Model Context Protocol (MCP) is no longer just a Claude Code story. It has settled in as an industry standard protocol. It lets LLM agents exchange tools, resources, and prompts with external systems (databases, issue trackers, browsers, internal APIs) in a standardized way.
Attaching an MCP server in Claude Code is about as simple as declaring it in a config file.
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
},
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://localhost/mydb"
]
}
}
}
Once attached, the agent can do things like “read this issue and find the related PR” or “check the actual schema with this query” against the real systems. The point is that it looks at the real DB, not an imagined schema.
A caution: the more MCP servers you attach, the more tool definitions eat into the context. With 40 or 50 tools loaded, their schemas alone take a lot of tokens, and the model may get confused about which tool to use. Recently, a pattern of lazy-loading tool schemas (deferred/search style) has been standardizing to solve this. Only the names are shown, and the schema is searched for and loaded right before the actual call.
Hooks: Don’t Use an LLM Where You Need Determinism
An agent’s weakness is non-determinism. If you enforce a rule like “always run the formatter before committing” only through a prompt, the model follows it nine times out of ten and forgets once. Hooks solve this.
A hook unconditionally runs a fixed shell command on a specific event (before or after a tool runs, at session end, and so on). The harness runs it directly rather than the LLM deciding, so it is 100% deterministic.
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "prettier --write \"$CLAUDE_FILE_PATH\" 2>/dev/null; true"
}
]
}
]
}
}
This hook runs Prettier automatically every time the agent edits a file. You don’t need to ask the agent to “fix the formatting.” Lint, type checks, secret scans, test triggers, and anything else that “must always happen” should all go down into hooks.
The principle is simple. Use an agent when you need judgment, and a hook when you need a guarantee.
Toris’s operating principle is the same. In a one-person operation there is no teammate to catch the rules a prompt missed, so the default is to push any rule that must be followed down into a hook.
Plan Mode: Agree Before You Execute
Plan mode is a mode where the agent first presents a plan for what it will change and how before touching any files, and only starts executing once the user approves.
It is especially useful for large refactors and risky changes. If the agent starts tearing up 20 files right away, it is hard to undo, but in plan mode you can read “in this order, these files, changed this way” and change direction. Thirty seconds invested in the planning stage prevents five minutes of flailing in the wrong direction.
Background / Async Agents
Another big trend is async and background execution. You can now throw a task into the background and do something else.
- You run a long test suite or build as a background process, and when it finishes the agent picks up the result and continues.
- You hand multiple tasks to several agents at once and watch the progress of each.
- You can hook one into a scheduler and make it a cloud agent that runs periodically. For example, one that checks dependency vulnerabilities every morning and opens a PR.
This is a shift from “AI helps me type next to me” to “AI runs several tracks of work in the background.” However, if parallel agents touch the same file they collide, so isolation (worktrees and so on) and task-splitting design become important.
Multi-Surface: Terminal, IDE, Web
Claude Code is no longer only in the terminal.
- Terminal: The original and most powerful surface. Full access to the shell, files, and processes.
- IDE integration: In VS Code, JetBrains-family IDEs, and others, with inline diffs, automatic recognition of file context, and an approval flow inside the editor.
- Web: Access from a browser to run and monitor background/remote agents. A scenario where you don’t have to keep your local machine on.
Because the same agent core is used from several entry points, carrying the context of work started in the terminal over to another surface is getting smoother.
Model Tiers: As of Early 2026
Claude Code picks models according to the nature of the work. As of early 2026, the picture is roughly this.
| Tier | Character | Good for | Trade-off |
|---|---|---|---|
| Opus | Top-tier reasoning | Complex architecture design, hard debugging, long-term planning | Highest token cost and latency |
| Sonnet | Balanced workhorse | Everyday feature work, refactoring, review | The default for most real work |
| Haiku | Fast and cheap | Simple edits, classification, bulk fan-out subagents | Poor fit for deep reasoning |
The practical strategy is a mix: the main agent on Sonnet or Opus, and fan-out exploration subagents on Haiku. Using the top model for repetitive work like exploration and summarization just burns money. (Specific prices change often, so always check the official docs.)
For Toris, this tier mix is not performance tuning but cost management. We have no fixed payroll, but agent usage is our development cost, so which tier goes to which task shows up directly in profit and loss.
When It Shines and When It Wastes Your Time: Honest Trade-offs
Where it shines:
- Tasks with a clear goal plus a way to verify (tests, type checks). The agent can run and fix things on its own.
- Exploring and understanding a wide codebase. It grasps “where and how this feature is tangled up” in no time.
- Boilerplate, migrations, and applying repetitive patterns.
Where it wastes your time:
- Context limits: With a huge codebase you can’t fit everything in. Designing what goes into the context becomes your job.
- Cost: Agent loops use a lot of tokens. Running large jobs on Opus for a long time makes the bill big. The model tier mix and subagent isolation are cost management.
- Non-determinism: The same request is handled slightly differently each time. Rules that need a guarantee must go down into hooks.
- Vague goals: With a fuzzy instruction like “make this code better,” it puts effort in the wrong place. The clearer you make the goal, constraints, and verification criteria, the better the result.
Where It Is Heading
To sum up, the direction is clear. Claude Code is moving from a single conversational tool to an orchestration runtime where multiple agents run in parallel. It splits context with subagents, hardens know-how with skills, connects to the world with MCP, secures determinism with hooks, and widens where it runs with background and web.
The homework left for developers is not coding itself but harness design. Which work goes to which model and which agent, what goes into and out of the context, what gets enforced with hooks: this design sense is what separates skill in agentic development in 2026.
How Toris Applies This
For each new extension axis, we pick one real repetitive task, try it in the workflow, and harden it into a standard asset such as a skill, hook, or rule file only when we judge the savings to outweigh the upkeep. Even after hardening, we recheck those assets every time the tool is updated. If your team needs the experience we’ve built running agents this way, you can talk with us through Toris’s AI and work automation consultation.
▶️ Related Video
References
Advertisement