27 Claude Code Settings for Autonomous AI Agent Workflows

Why Your Workflow Hasn't Changed Despite Using Claude Code Daily

"I remember running /init. But I have no idea when I last updated it."

Does this sound like you? You installed Claude Code, spent the first few days configuring it, and you chat with it daily. Yet, compared to three months ago, the structure of your work remains largely unchanged.

This isn't a problem of usage; it's a problem of positioning.

If you keep using Claude Code as a "tool that answers when spoken to," you'll end up typing the same instructions every morning, getting similar responses, and copying them into your work. You might be more efficient, but the way your work progresses hasn't fundamentally shifted.

Change happens when you start treating Claude Code as a "design target." Who knows what in which context? Which tasks are delegated to whom? What moves even when no human is present? When you start thinking about this as design, Claude Code begins to behave entirely differently.

The 27 features published by @sairahul1 (https://x.com/sairahul1/status/2070428662080618607) systematically list functions that should be used from this design perspective. Swarm has interpreted these through the lens of agent design and organized them into a format applicable to actual business contexts.

Twenty-seven might seem like a lot, but there are only three core principles. We will explain this structure in order starting from the next chapter.

The Three Disciplines Connecting the 27 Features

Looking at the 27 features, they might seem scattered. There are shortcuts, file settings, voice input, and test execution. However, when decoded, they can be organized into groups that answer three questions.

Discipline 1: Context Design (Features 1–5)

Creating a state where Claude knows "whose project it is, for what purpose, and how much it currently understands." If this breaks, you have to explain everything from scratch every time.

Discipline 2: Delegation Design (Features 6–14)

Structurally handing over tasks and authority to Claude. Instead of saying "fix the bug," you organize and hand over "what is broken and what the constraints are," which changes the probability of a first-time resolution.

Discipline 3: Autonomy Design (Features 15–27)

Designing a mechanism where Claude can keep moving without constant human instruction.

These three stages are also the order in which you should use them. If the context isn't set, delegation becomes sloppy. If delegation isn't designed, autonomy runs wild.

What you need to be conscious of here is how to change the structure of "me instructing Claude every morning." If you are throwing the same tasks into the chat every morning, the human is still the subject. When the design switches to a structure that moves Claude, what you do in the morning changes.

First, let's look at the five features of Context Design.

Basics of Context Design

The goal of context design is to give Claude the "context of this project." Without context, every conversation starts from a blank slate.

The first thing to run is `/init`.

When you open a project for the first time, run this first. Claude scans the codebase structure, dependencies, and build commands to automatically generate CLAUDE.md. This file becomes the project's "blueprint."

This is where many people stop. They remember running /init, but don't know when it was last updated. If left as generated, the contents of CLAUDE.md will drift away from reality as the project changes. By operating on the premise of weekly updates, Claude can always move within the latest context.

Next, `/statusline` is useful to set up.

A status line will appear at the bottom of the screen. You can visually grasp what is running and which processes are active. It can also be integrated with custom status lines in Vim or Neovim, allowing you to set it up according to your existing editor environment.

The third is voice input.

You can pass complex requirements by speaking using ⌃⌘Space on Mac or native voice input on iOS and Android. You can pass long instructions like "I want this component to move like this for this reason, but don't change the existing styles" without typing. Since you can pass thoughts as they flow, it saves time spent organizing while typing.

Use `/context` to check the state of the context.

You can see what is currently in the conversation and the context window usage in real-time. In long sessions, the content of the initial blueprint tends to fade. This command allows you to monitor that.

The reset operations for that are `/compact` and `/clear`.

/compact compresses the entire context into a summary. /clear is a complete reset. If you continue a long session, Claude's answers may become vague. This is a sign that the context is clogged. By periodically using /compact, you can maintain output quality.

Before: In the latter half of a long session, Claude gives a misaligned answer even when saying "following the design policy discussed earlier."

After: Compressing with /compact before continuing keeps the output accurate to the policy.

The five features do one thing: maintain the state of Claude "knowing" as a design. That becomes the foundation for the next step, Delegation Design.

The Art of Passing Problems

Once the context is set, the next step is how to pass the problem. The accuracy of the response changes completely depending on whether you say "fix the bug" or pass it in a structured way.

First, use plan mode (`Shift+Tab`).

Before major changes, this mode outputs "only the plan" instead of executing. You can check what Claude intends to change and in what order beforehand.

Instead of fixing errors after they occur, you can point out "that's wrong" at the planning stage. Incorporating this one step into your design significantly changes the frequency of unexpected changes. As you continue to use it, you'll realize it reduces the effort of checking "why was this file rewritten?" after the fact.

Second is the structuring of problems, constraints, and context.

If you just say "fix the bug," Claude tries to fill in the assumptions itself. If those assumptions are off, the solution will be off.

The officially recommended format is to write "what is broken" on the first line, and "what was tried, constraints, and expected output format" from the second line onwards. Just passing it in this format changes the rate of one-shot resolutions. The way you pass the problem itself becomes a skill.

Third is `AskUserQuestion`.

This is a feature where Claude asks for clarification before proceeding when it encounters ambiguous requirements. Rework caused by implementation proceeding with vague requirements often happens when this feature isn't used. It's a design that pays the cost of confirmation before implementation.

Fourth is the self-verification step.

At the end of a task, tell it to "run tests and confirm the build passes before finishing." Instead of adding this manually every time, writing it in CLAUDE.md ensures it runs automatically at the end of every task. Instead of Claude stopping in a state where things don't work after a change, the loop including verification is completed as a single task.

Taking proactive steps with plan mode and automating reactive steps with self-verification. The structure of the development flow changes the moment these two are incorporated into the design.

In the next chapter, we will look at designing the delegation of continuous tasks to Claude.

Designing Delegation

In the previous chapters, we organized how to communicate with Claude and how to let it retain memory. Next is about changing "who becomes the subject."

10. Subagents

If a human manages procedures during long tasks, they will inevitably get stuck. Constantly saying "do this next, then do that when finished" means the human, not Claude, is handling the coordination.

Using TodoWrite or Task tools, Claude decomposes tasks into subtasks and executes them in parallel. In official terms, this is "concurrent subagent execution"—a structure where multiple child Claudes move simultaneously. Different Claudes run research, implementation, and testing at the same time. Humans don't need to hold the procedure.

11. Custom Skills (Workflow Template Files)

Placing Markdown files in the .claude/commands/ directory allows you to call instruction sets with /command-name. In the context of Swarm, it's easier to think of these as "SKILL.md (Workflow Template Files)."

Before: Writing "Please conduct a competitor survey. The steps are 1, 2, 3..." every time.

After: Just typing /competitive-research in one line.

The time spent writing the same instructions repeatedly disappears. If shared with a team, it becomes a template where anyone can get the same quality of output.

12. Model Selection

You can switch models within a session by pressing Alt+P. A realistic three-stage usage is: high-reasoning models for design and conceptual phases, lightweight models for simple implementation, and mid-tier models for debugging.

Matching the model's power to the weight of the process improves both cost efficiency and response speed simultaneously.

13. Automatic CLAUDE.md Updates

If you tell Claude to "add what you learned in this project to CLAUDE.md," Claude will update CLAUDE.md itself. It's a structure where the blueprint grows on its own.

By adding this command once a week, CLAUDE.md becomes a "living document." Even if humans don't write reflections, Claude accumulates what it has learned.

14. External File Linking

You can pass files, URLs, or Issues as context using @{file_path}. It's a mechanism to complete "read this file before working" in one line.

Before: Copying and pasting file contents into the prompt.

After: Just writing "Check the settings by referring to @src/config.yaml."

Designing delegation means creating a system that hands the subject over to Claude. When procedures, templates, references, and memory are all in place, humans only need to think about "what to create."

However, as delegation increases, so does the risk of "Claude moving in a direction different from intent." In the next chapter, we'll look at how to stop that drift early.

Stopping Drift Early

As delegation to Claude increases, one problem becomes more likely: realizing it has gone in a completely different direction than intended. We call this drift.

Drift isn't something to fix later; it can be prevented by taking proactive design steps.

15. Immediate Stop

If you feel the output is heading in an obviously wrong direction, you can stop it immediately with the Escape key. "I'll fix it after it's finished" is a mistake. The further generation proceeds, the higher the correction cost. Stopping midway and fixing the prompt saves both time and tokens.

If you intuitively think something is wrong, stop it without hesitation. The speed of this judgment directly impacts accuracy.

16. Requesting the First Output as Evidence

A proactive design is to say "show me just the first output first, and I'll decide whether to continue" before starting work.

Instead of letting it spend 10 minutes in the wrong direction, confirm with the first output before letting it run. This is the idea of nipping drift in the bud. It's essential for long-duration tasks or work starting with ambiguous directions.

Before saying "I'll leave the rest to you," insert "let me check the beginning." It's just one step, but this proactive move changes the result.

17. Notification Hooks

Staring at the screen waiting for a long task to finish is a waste of time. By placing a script in ~/.claude/hooks/, you can receive desktop notifications when a task is completed.

Set it up once. From then on, even if you are doing other work, Claude will notify you when it's done. It's a design that eliminates the act of waiting.

18. Passing Screenshots

Explaining UI bugs in words is surprisingly difficult. Instead of verbally saying "a red error appeared in the top left and the button can't be pressed," passing a screenshot is faster.

Claude receives the image and returns the error content, cause, and fix suggestions as they are. It's completed with "look at this screen."

The 18 features introduced so far are all based on the premise of one person operating. In the next chapter, we enter the structure of "using as a team," where multiple Claudes run in parallel and integrate.

Parallel Operation and Integration

While using Claude Code as a chat tool, you can't start the next task until one is finished. But by changing the design, you can create a structure where multiple Claudes move simultaneously.

Start with Chrome DevTools integration. Since you can pass browser error logs and network logs directly to Claude Code, you no longer need to verbally explain situations like "there's a red error in the console but I don't know what's happening." The official documentation has a dedicated page for this, positioning it as the gateway to debugging.

Session management also changes. You can resume the latest session as is with claude --continue, or choose from a list of sessions with claude --resume. Furthermore, by naming sessions with /rename, you can manage multiple tasks in parallel with the same feeling as Git branches. By using sessions named "Auth," "Payment," and "Dashboard," the cost of switching context becomes almost zero.

And the core of parallel operation is the combination with git worktrees. Typing claude --worktree feature-auth launches a session where the branch is completely isolated by the worktree. If you run Auth, Payment, and Dashboard in separate worktrees, three Claudes will proceed with development in parallel. Since each is in an independent workspace, no conflicts occur. The structure to finish a week's worth of development in one day is established here as a design.

It's also necessary to organize thoughts on MCP. An MCP server isn't always the optimal solution. The official documentation states that "CLI tools are the most context-efficient way to interact with external services," and CLI tools like gh or aws are said to have high context efficiency and are less likely to hit rate limits. With just the gh command, Claude Code can autonomously create, update, and close GitHub Issues. Having a judgment axis to check if a CLI tool can be used before adding an MCP keeps the design simple.

When parallel design is possible, humans no longer need to manage the sequence. This is because the design switches to passing multiple subjects to Claude simultaneously. Next, we will evolve this designed parallel processing into a system that keeps moving even when you are away from your desk.

Autonomous Operation

The next question after parallel design is, "Where do I need to be during that time?" When autonomous operation is designed, a state is created where work progresses even without a human present.

/loop is a feature that runs automatic polling within a session. The official explanation is "Quick polling while a session is open," and it repeats specified operations while the session is open. Using --resume or --continue allows you to resume sessions that haven't expired, and according to experience reports in the original article, cases of unmanned operation for up to three days have been reported. While we haven't confirmed that number of days directly with official sources, it certainly functions as an entry point for long-duration autonomous operation.

Remote Control, added in Q1 2026, is a feature to operate Claude Code sessions running locally from a smartphone or PC browser. While the code remains local, only messages are exchanged through an encrypted channel. It was released as a research preview in February 2026. A scenario is established where the local Claude Code keeps moving just by sending "check if the tests passed" from a smartphone while out.

Natural language queries to databases can also be incorporated into the design. Connecting to SQLite, PostgreSQL, or MySQL via MCP allows you to retrieve data using Japanese (or English) like "tell me the users registered last week." The official guide suggests running claude mcp add to connect external tools like your database, allowing you to delegate data confirmation routines to Claude without writing SQL.

There are also four features to control the depth of thought. ultrathink triggers extended thinking of up to 31,999 tokens just by including that keyword in the prompt. There is a hierarchy: think is 4,000 tokens, megathink is 10,000 tokens, and ultrathink is 31,999 tokens. The correct way to use it is only for the truly difficult 10% of problems, such as complex architecture decisions, security implementations, performance optimization, and large-scale refactoring. Using it for every query will inflate costs pointlessly.

/effort ultracode is a setting to enable xhigh reasoning and dynamic workflows for the entire session. While ultrathink is a one-turn keyword, ultracode remains active throughout the session. It's suitable for "session-wide heavy work" like auditing an entire codebase, migrating hundreds of files, or high-risk tasks. However, since token costs increase significantly, discerning the situation determines the effectiveness.

Claude Code, which started with typing into a chat to move it, has reached the gateway of a system that detects events and moves autonomously. Instead of humans moving it, the design moves Claude. Next, we will confirm where the difference in productivity essentially arises through all these features.

Why Results Differ with the Same Claude Code

People who develop quickly don't necessarily have special abilities. They are simply designing more systematically.

For example, consider the situation of running /init. Even if the same command is typed, the output quality several months later will be completely different between a CLAUDE.md that is updated weekly and one that has been left since setup. This is because the freshness and accuracy of the context Claude reads directly impact the quality of the output.

To use a kitchen analogy, the level of cooking is determined more by how the kitchen itself is organized than by which ingredients are used. Claude's model performance is provided equally to all users. The difference lies in the accuracy of these three points: how the context was organized, how instructions were systematized, and how autonomous operation was designed.

Before discussing "which model to use," try checking when your current CLAUDE.md was last updated. That will tell you the current state of your design.

So, where should you actually start? In the next chapter, we will organize a step-by-step introduction sequence.

Where to Start: A Step-by-Step Introduction Guide

You don't have to try to remember all 27 at once.

In the first week, narrow it down to just four.

Create a project map with /init.
Periodically compress context with /compact.
Separate exploration and execution with plan mode (Shift+Tab).
Pass self-verification steps (tests, builds) to Claude.

With just these four, the quality of the session will fundamentally change. Since Claude starts moving with an accurate grasp of "what should be done," the amount of rework will visibly decrease.

From the second week onwards, add Delegation Design on top of this foundation. Summarize instructions into a reusable format with Custom Skills, adjust the weight and speed of processing with model selection (Alt+P), and establish a habit of updating CLAUDE.md weekly. This is the stage where you change instructions from "something written every time" to "something that accumulates."

After one month, proceed to subagents, git worktrees, and parallel sessions. You'll have a system where you can focus on design and confirmation while developing multiple features simultaneously.

ultrathink and ultracode are tools to be used for the first time in this flow when you encounter "truly difficult problems." They are not tools to bring out for every problem.

By taking these steps, you will come to understand through experience "why each feature is necessary." Please start with the four items for the first week.

Everything Changes the Moment You Treat It as a Design Target

The moment you start treating Claude Code as a design target, the quality of the session fundamentally changes.

I'll summarize the content introduced in this article in a form you can save and refer back to.

The four items—/init + /compact + plan mode + self-verification—are the most fundamental basic designs.
Systematize the reuse of instructions with Custom Skills, and grow CLAUDE.md as a "living blueprint" updated weekly.
When you start using subagents, productivity changes from addition to multiplication.
The ironclad rule is to detect drift early and stop immediately. Always request evidence in the first output.
You can develop multiple features simultaneously with git worktrees + parallel sessions.
Set up autonomous operation with /loop, and confirm or instruct from a smartphone with Remote Control.
ultrathink is a dedicated tool for the "truly difficult 10%." It's not for every problem.

If you try even one of the features mentioned in this article, your relationship with Claude Code will gradually begin to change.