Tari Ibaba

Hooks are a powerful way to add deterministic control over an AI agent.

As you know these agents can be unpredictable at times.

That’s why hooks exist — they make AI agents more predictable and reliable by enforcing critical behavior with code, instead of relying on prompts.

Hooks are scripts that run automatically at key points in Claude’s workflow — like before an external tool runs or after Claude changes a file.

Instead of relying on prompts Claude might follow or ignore — hooks let you control these things at the system level.

You can automate repetitive work that needs to happen only when the agent does something — or give Claude extra instructions only when it needs them.

Let’s look at the various ways hooks upgrade coding agents to help you build faster as a developer.

1. Dynamic context injection — give Claude the right information at the right time

Big system prompts get messy fast.

You add coding rules. Architecture docs. Security requirements. Then instructions for one small part of your codebase.

Soon Claude carries lots of context it doesn’t need at all times.

Hooks give you another option — inject information only when it becomes useful.

Say Claude starts changing /src/payments.

A PreToolUse hook could give Claude your payment security rules before it makes the change.

If Claude works on database migrations you can load your migration rules instead.

A SessionStart hook could also load GitHub issues or Jira tickets when Claude starts.

Less noise — more useful context.

2. Hard security guardrails — stop dangerous actions before they happen

❌ “don’t run dangerous commands”

❌ “don’t expose secrets”

These are not things you should put in prompts.

Use hooks.

A prompt tells Claude what you want it to do — a hook can control what it actually can do in the real world.

A PreToolUse hook can inspect an action before Claude runs it. If the action looks unsafe according to your specifications, the hook can block it.

You can block commands like rm -rf or force-pushing to main. You can also protect .env files and API keys.

You don’t need to trust Claude to remember the rule every time — your system enforces it.

3. Enforce engineering standards — catch bad code before you review it

Claude can write code quickly.

But you don’t want to keep saying “run the tests” or “check the linter.”

Hooks can do that work automatically.

A PostToolUse hook can run your tests whenever Claude changes source code.

If something fails the hook can send the error back to Claude — Claude sees what broke and can try to fix it.

The workflow becomes:

Claude changes code → tests run → something fails → Claude fixes it.

You can use this for testing, linting, type checking and other quality checks.

You define the rule once — Claude follows it automatically.

4. Automatic code formatting — don’t waste AI time on formatting

Formatting is another job you probably shouldn’t give to the model.

You don’t need Claude thinking about spaces and indentation when tools already handle that well.

A PostToolUse hook can run Prettier, Black, or gofmt whenever Claude changes a file.

That means cleaner Git diffs and fewer formatting problems during review.

It also saves prompts — you don’t need to keep asking Claude to fix imports or indentation.

Claude solves the engineering problem — your formatter handles formatting.

5. External tool orchestration — connect Claude to the rest of your workflow

Hooks can run normal system commands.

So they can connect Claude to other tools you already use.

Say Claude spends 20 minutes working on a task — you don’t need to watch the terminal.

A hook could send you a Slack or Discord message when it finishes.

You could also use hooks for voice updates, human approvals, audit logs and cost monitoring.

You can even track token use and stop a session when it reaches a set limit.

Claude does the work — hooks handle what happens around it.

Hooks mean less failure and more reliable automation

Claude Code hooks let you move important rules out of prompts and into your development environment.

Security rules can block actions. Tests can run themselves. Context can appear only when Claude needs it.

Formatters can clean up files. Other tools can react when Claude finishes work.

Instead of constantly telling Claude what to do — you build a system that keeps it on track.

That means less babysitting. Fewer repetitive prompts. Faster feedback.

And much more predictable AI-assisted development.

grill-me has been one of the most transformative skills in the AI coding ecosystem.

It’s a powerful skill that turns Claude Code into an interviewer to poke holes in your assumptions and find flaws in your thinking.

It reveals blind spots, catches subtle problems and helps you make better technical decisions.

It gives you a deeper understanding of your overall development process, and improves the overall quality of your code.

Let’s look at the key features that makes it such a valuable part of your workflow.

1. Inverted roles — find blind spots before you build

There is a problem with asking AI to review your work — you still need to know what to ask.

If you forgot about concurrency then you may never ask about concurrency.

/grill-me solves this by taking control of the questions.

Say you tell it that users upload files before you add a processing job to a queue. It might ask:

What stops the same upload from being processed twice?

This is an important edge case you might have never thought of.

Your answer gives it somewhere new to dig.

Which parts of the processing pipeline are actually idempotent?

You are no longer asking AI to confirm your design. You are defending it — which can expose crucial missing requirements before you spend hours building the wrong thing.

2. Socratic pressure testing — catch problems before production

A good grill does more than run through a checklist. It questions the assumptions behind your answers.

It looks for the parts of a design that seem obvious but have not been fully thought through.

This can uncover race conditions and security risks. It can also find weak retry logic or scaling limits that normal AI conversations may miss.

The benefit is clear — you find failure cases during design instead of finding them at 2 a.m. in production.

3. Dynamic pressure testing — make better technical decisions

/grill-me doesn’t follow a fixed list of questions. It changes direction based on your answers.

A strong answer can move the conversation forward. A vague answer gives the AI a reason to dig deeper — especially when your reasoning depends on an assumption you haven’t proved.

This pushes developers to turn vague ideas into clear technical decisions.

It also makes those decisions easier to explain later. You have already had to think through the tradeoffs and defend why your approach works.

4. Customizable personas — get expert review on demand

You don’t always need the same kind of review.

A friendly grill can act like a senior engineer helping you spot things you missed. A tougher one can challenge every weak assumption you make.

You can also change who is doing the grilling.

Ask for a security engineer and the questions can focus on authentication or trust boundaries. Ask for an SRE and the focus can move to outages and recovery. A database expert can dig into indexes and transactions.

It gives developers another set of eyes without waiting for the right expert to become free.

5. Context-aware scrutiny — get feedback on your actual code

Generic architecture questions only go so far.

/grill-me becomes much more useful when it can read the project itself. It can use your code and specs to understand how the system really works.

That makes its questions specific to your project rather than based on textbook problems.

It also saves developers from explaining everything from scratch. The AI can find facts in the project — while the developer focuses on explaining and defending the decisions behind them.

A sparring partner — ship with fewer surprises

AI has made writing code much faster.

It has not made bad assumptions cheaper.

In fact AI agents can turn one bad assumption into thousands of lines of convincing code very quickly.

/grill-me adds friction before that happens — the useful kind.

Attack the idea before implementing it. Find the failure cases before users do. Question the assumptions before they turn into technical debt.

AI coding agents are great — until they go down the wrong path.

Maybe Claude Code changed five files before you noticed the problem. Maybe the first idea was wrong — and every prompt after that made things worse.

You could use Git to clean things up…

But Claude Code has a much faster option for this kind of trial and error: /rewind.

It lets you return to an earlier checkpoint quickly. But it does a lot more than just undo code.

1. Multiple restore options let you keep the exact parts that worked

When you run /rewind and pick a checkpoint, Claude Code gives you three restore options.

Restore Code and Conversation takes both your files and chat back to that point.

Use this when the whole attempt went wrong. You can throw away the bad code and the reasoning that led to it.

Restore Code Only is more interesting.

Claude puts the files back but keeps the current conversation. So Claude can still know what it learned during the failed attempt — even though the code itself is gone.

Maybe it found an edge case. Maybe it learned that an API works differently than expected.

You can keep that knowledge and try a better approach.

Restore Conversation Only does the opposite.

Your changed files stay in place. But Claude’s conversation goes back to the earlier checkpoint.

This works well when you like the code but the chat has become messy. You get a cleaner starting point without losing the work already sitting in your files.

So /rewind isn’t just undo — it lets you choose which state you want to keep.

2. Context summaries keep long coding sessions useful

The /rewind menu isn’t only about undoing things.

It also has “Summarize from here” and “Summarize up to here” for when the context gets long.

These options don’t change your files.

Instead they compress parts of your conversation into a shorter summary. This helps when a long coding session starts filling Claude’s context window.

Maybe you spent 30 minutes debugging an approach that didn’t work.

Claude doesn’t need every message from that process. It may only need to know what you discovered.

You can summarize that section and keep moving.

So /rewind is also a context management tool — not just a recovery tool.

3. Restored prompts make it faster to fix a bad instruction

Claude Code also saves you from retyping your prompt.

When you restore conversation state, it puts the original prompt from that checkpoint back into the input box.

Claude Code restores the original prompt on rewind:

Say you originally wrote:

Refactor the payment service so retries happen at the transport layer.

Claude tries it. You inspect the result and realize your prompt was too vague.

Rewind and the prompt comes back. Now you can edit it with clearer rules and try again.

The workflow becomes simple:

Prompt → Try → Inspect → Rewind → Edit → Try Again

It’s a small feature — but it makes experimenting much smoother.

4. Automatic checkpoints let you experiment without managing Git

Claude Code creates checkpoints as it edits files.

This works separately from Git. You don’t need to make a commit before every experiment or create temporary branches just so you have somewhere to return to.

You can ask Claude to try something.

Don’t like it? Rewind.

Then try something else.

This doesn’t replace Git. Git still gives you long-term project history and branches.

/rewind solves a smaller problem — quickly recovering from Claude’s changes while you’re working.

5. Key limitation to be aware of

There is one big limit.

/rewind tracks changes made through Claude’s file editing tools. It can’t reliably undo side effects from shell commands.

Think about commands like:

ShellCopied!

rm file.txt

mv old/ new/

npm install

The same warning applies to database migrations and deployments.

If Claude runs a migration that changes your database, /rewind can’t magically return that database to its old state.

So don’t treat checkpoints as a full backup system.

They are a safety net for Claude’s tracked edits.

And that’s what makes /rewind useful.

You can try an idea. Keep what Claude learned. Throw away what didn’t work — then take another shot.

As coding agents make bigger changes to our projects, being able to recover quickly may matter almost as much as getting the first attempt right.

For the past few years until now it’s been all about Large Language Models (LLMs).

From generating code to drafting essays, LLMs showed us their remarkable ability to work with language and solve complex problems.

But inside modern AI-powered software systems, an interesting problem emerged.

Today, as developers we increasingly use large conversational models for tasks that don’t need any conversation at all:

• deciding which action an automated agent should take next (like which button to click on a page)
• tagging and sorting text data
• deciding the next step of an AI-powered workflow
• routing customer-support tickets
• checking whether content violates a policy

In these situations, the application doesn’t need generated text. It needs a decision. It needs cold hard data — and fast.

That is the problem that Jev, a new trending model from TypeSafe AI, is here to address.

Jev represents an emerging category of non-autoregressive decision models.

Instead of generating natural-language responses, these models take application state and return constrained, probabilistic decisions.

They skip the LLM conversation layer entirely to focus on pure processing logic and decision making, which makes it much faster, among other benefits.

1. Much lower latency in AI model processing

Traditional LLMs generate responses autoregressively, producing one token after another. That makes sense for paragraphs or code, but it is inefficient when the goal is simply to “approve or reject” or “choose one of these categories.”

Jev-like models instead produce bounded decisions directly.

According to performance claims associated with Jev, this faster processing can take roughly 70–300 milliseconds — as much as 40x to 200x faster than using conversational LLMs to do it.

This makes AI decisions much more practical for UI automation, interactive applications, automated agents, and other latency-sensitive workflows.

2. Fewer parsing problems

LLM developers know the familiar instruction: “Respond ONLY with valid JSON.”

Yet models can still occasionally return Markdown, extra explanations, unexpected fields, or invalid values. Developers compensate with validation, constrained outputs, and retry logic.

Jev takes a different approach by eliminating arbitrary text generation. Its interface is based on constrained primitives like:

• Choice: Select an option from a predefined set.
• Noul: Evaluate a boolean condition with a probability.
• Score: Evaluate input against an ordered scale.

Because it knows all its outputs in advance, applications can avoid many of the parsing and formatting problems associated with free-form generation.

3. Lower model processing costs

Cost becomes especially important when AI operates as invisible infrastructure.

A chatbot might receive a handful of requests per user — but a backend model could be invoked hundreds of times during automated workflows.

TypeSafe AI lists Jev’s input processing at approximately $0.042 per million tokens — and without an output-token charge — because it does not generate text.

We’re getting reports of cost reductions of roughly 40× to 400× for some structured classification workloads compared with generative LLMs.

The underlying idea is simple: if an application needs a classification rather than a sentence, paying to generate that sentence may be unnecessary.

4. Usable confidence scores

Conversational models often express incorrect answers with the same confident tone as correct ones. For automated systems, that makes uncertainty difficult to interpret.

Decision models can instead expose probabilities directly and optimize for calibration. Jev uses an approach called Reinforcement Learning for Calibrated Decisions (RLCD).

In principle, well-calibrated probabilities allow us as developers to create practical automation thresholds. High-confidence decisions might execute automatically, medium-confidence cases could go to human review, and low-confidence cases could be escalated.

That turns uncertainty into something application code can actually use.

5. Parallel evaluation

Software often needs multiple judgments about the same input — for example determining a document’s compliance status, sentiment, risk level, priority, category, and routing destination.

Rather than making separate generative calls, we can potentially evaluate multiple decision targets together with non-autoregressive models.

TypeSafe AI describes this approach as speculative fan-out, reducing the overhead involved in repeatedly processing the same application state.

The bigger picture

Models like Jev are not necessarily replacements for conversational LLMs. They address a different layer of the AI stack.

Generative models remain valuable for open-ended reasoning, writing, coding, and synthesis. Decision models are designed for something simpler:

state in → probability or decision out.

That could lead to a more specialized AI architecture, where powerful generative models handle difficult reasoning while fast decision models manage the thousands of routine judgments underneath.

It’s the world where AI becomes more than something users talk to.

Where it’s part of the software itself—routing requests, evaluating conditions, selecting actions, estimating risk, and determining when more expensive reasoning is actually necessary.

CLAUDE.md is so much more than most developers realize.

It’s supposed to be a special file for providing persistent instructions and context to Claude Code.

But many developers think they can just dump whatever they like inside it — some feel it’s just a fancy way to avoid writing the same prompts over and over.

Some don’t even ever use it — missing out on one of the most powerful ways to shape how Claude behaves inside a project.

The reality is that CLAUDE.md is far more nuanced than it appears. Understanding a few non-obvious facts about it can completely change how you work with Claude Code, and the results it produces for you.

Here are five things every developer should know about CLAUDE.md.

1. It’s not a README or project summary

Actually not a very good CLAUDE.md:

A README exists to explain a project.

A CLAUDE.md exists to guide an agent working inside that project.

The most effective files don’t try to document everything. Instead they focus on specific expectations, workflows, constraints, and preferred ways of working.

For example:

• Particular project-specific commands to run — or NOT run
• What must happen before code is merged
• Which patterns should be avoided when responding to prompts
• How tasks should be approached

Thinking of CLAUDE.md as documentation often leads to bloated files. Thinking of it as a behavioral contract usually leads to better results.

2. It’s not a system prompt

One common misconception is that CLAUDE.md functions like a system prompt.

It doesn’t.

Claude Code loads the contents of the file into the model’s normal user context — it’s treated as important guidance rather than an untouchable source of truth.

It’s not an unbreakable instruction layer that reigns over every other context.

This is why clear, specific instructions tend to work much better than vague recommendations.

3. There can be more than one CLAUDE.md

Many developers assume there is a single CLAUDE.md at the root of a project.

But actually Claude Code supports a layered memory system.

Instructions can exist at multiple levels and be combined as Claude works through different parts of a codebase.

This makes CLAUDE.md less like a project configuration file and more like a hierarchy of contextual instructions that shapes behavior in different situations.

4. Claude can automatically generate your first CLAUDE.md

A surprising number of developers still start from a blank file.

Claude Code includes an /init command that can inspect a repository and generate an initial CLAUDE.md automatically.

The generated file won’t be perfect, but it provides a useful starting point and can save time by capturing common project information that would otherwise need to be written manually.

For many teams, it’s the fastest way to establish a baseline memory file.

5. CLAUDE.md is only one layer of Claude’s massive memory system

Perhaps the most important thing to know is that CLAUDE.md is not Claude Code’s entire memory system.

It’s just one layer.

Claude can draw context from user-level memory, project-level memory, session context and many other memory sources.

So when Claude successfully remembers how your team works, that behavior is often influenced by more than a single file.

The most interesting thing about CLAUDE.md is that it represents a new way of programming behavior.

Traditional software is configured through code and settings. Claude Code introduces the idea of configuring an agent through natural language instructions.

That’s why two developers can use the same model and get very different outcomes. The difference isn’t the model — it’s the behavior defined by the memory and instructions surrounding it.

Claude Code can explore your entire codebase, edit hundreds of files, run dozens of commands, and handle all sorts of tasks in the background.

This autonomy is useful, but it also creates a simple problem: keeping track of what’s happening.

How much are you using? What exactly is running in the background? Is your Claude Code setup even working properly?

Fortunately, Claude Code has several slash commands that give you visibility into your sessions. Here are seven worth knowing.

1. /status — Check your current setup

When you want a quick overview of your Claude Code environment, run:

/status

This opens status information about your current setup, including details such as the Claude Code version, model, account, and connectivity.

It’s especially useful after changing models, updating Claude Code, or switching environments. Before debugging your project, it can be worth confirming exactly what setup you’re working with.

2. /usage — Monitor your usage

Claude Code sessions can become surprisingly large. An agent might inspect dozens of files, run tests repeatedly, and iterate on a problem before finishing.

Run:

/usage

to see information about your Claude Code usage, limits, costs, and activity.

This gives you a better idea of how much you’re consuming during longer sessions instead of discovering it only when you approach a limit.

Claude Code also supports /cost as an alias for /usage, so older workflows that use /cost still work.

3. /tasks — See what’s running

Claude Code can perform work in the background while you continue with other things.

To see that work, run:

/tasks

This displays background tasks associated with your session and lets you manage them.

It becomes especially useful when you start using Claude Code more like an agent than a chatbot. If you have multiple processes running and can’t remember what Claude started, /tasks gives you a quick overview.

It’s like small task manager inside Claude Code.

4. /statusline — Keep useful information visible

Some information is useful enough that you shouldn’t need to repeatedly ask for it.

That’s where /statusline comes in.

It lets you configure Claude Code’s terminal status line so important session information remains visible while you work.

Rather than interrupting your workflow to check your environment, you can keep the details you care about directly in your terminal.

It’s a small feature, but good monitoring often works best when you barely have to think about it.

5. /stats — Review your usage patterns

Run:

/stats

to jump into statistics about your Claude Code activity.

In current versions, /stats is an alias for /usage that opens its statistics view.

It’s useful when you want to step back from an individual session and understand your broader usage patterns rather than focusing only on what Claude is doing right now.

6. /insights — Understand how you work

/usage tells you how much you’re using Claude Code. /insights helps you understand how you’re using it.

Run:

/insights

to generate an analysis of your Claude Code sessions, including your projects, interaction patterns, and areas where you commonly encounter friction.

For frequent Claude Code users, this can reveal recurring habits: what you delegate, where you get stuck, and how your agent-assisted workflow is evolving.

7. /doctor — Check Claude Code’s health

Sometimes your code isn’t the problem. Your setup is.

Run:

/doctor

to diagnose your Claude Code installation and configuration.

It checks for potential problems with the environment and settings, helping you identify issues that could cause unexpected behavior.

So before spending half an hour debugging a mysterious Claude Code problem, try /doctor.

More autonomy needs more visibility

The more work you hand to coding agents, the more important it is to be able to easily keep track of everything.

Commands like /status, /usage, /tasks, /statusline, /stats, /insights, and /doctor don’t write code for you.

Instead, they help you understand what Claude Code is doing, what’s running, how much you’re using, and whether everything is working correctly.

And as coding agents become more autonomous, this information becomes increasingly valuable.

Many developers are still just prompting and prompting — not realizing how much this feature could take their Claude Code experience to the next level.

Plan Mode transforms Claude into a clearly different kind of agent with a different objective.

Rather than immediately writing code, Claude shifts into a specialized, read-only, planning workflow designed to analyze, design, review, and document a solution before a single file is even touched —

And this ends up improving code quality and saving AI generation costs in the long run in the most complex projects — among other benefits.

Back then I would just give Claude a prompt like, “tell me how you’re going to do this first” at the end of my task prompt.

But trying to “plan” like this has some key issues that make it inferior to this built-in Plan Mode.

1. Plan Mode: Higher-quality code by giving Claude a different way of thinking

For one when Plan Mode is enabled, Claude receives a different set of specialized instructions that fundamentally change how it approaches problems.

Instead of optimizing for just code generation, it optimizes for planning in four distinct phases.

• Initial Understanding: Explore the codebase and identify relevant files and dependencies.
• Design: Evaluate implementation approaches and trade-offs.
• Review: Validate the proposed design against the realities of the codebase.
• Final Plan: Produce a concise roadmap explaining what should change and why.

It’s clearly a much more sophisticated way to plan than just a simple prompt.

2. Prevents excess token costs by using specialized planning models

This is another key difference.

Trying to plan with normal prompting can cost you a lot of tokens, especially in an existing, large codebase.

Going through all the files in a major codebase can consume a huge amount of context and tokens.

That’s why Claude Code’s special Plan Mode uses a specialized, lightweight “Explore” subagent (like Claude Haiku) during the discovery phase.

This lightweight agent is responsible for searching, indexing, and reading files before passing only the most relevant findings back to the primary model.

Instead of stuffing thousands of lines of code into the main context window, the Explore subagent filters out noise and returns only the information needed for planning.

This allows the primary model to spend its context budget on reasoning rather than file exploration.

3. Safer codebase with guaranteed immutability during planning

This is another key value that you can’t get from trying to plan by just prompting.

When you switch into Plan Mode, Claude’s ability to modify the codebase is restricted by the underlying CLI harness itself.

Write operations, file edits, and other mutating actions are removed from its available toolset.

In other words, Claude isn’t simply being asked not to make changes — it literally cannot make them.

This creates a genuinely safe environment for:

• Architecture reviews
• Migration planning
• Security audits
• Refactoring analysis
• Large-scale code exploration

So there’s no risk of an accidentally changing a file while you’re still weighing the design options.

4. Easy to get a big picture of the overall project plan

The plan doesn’t exist only in the conversation.

Behind the scenes, Claude generates a markdown-based planning artifact that can persist beyond the immediate session. The plan becomes something tangible rather than a temporary stream of thoughts.

You can open it up in your own editor, tweak Claude’s planned steps yourself, and then feed that modified markdown file back into the tool to execute.

It turns planning into a deliverable, which is really powerful.

Instead of reviewing ideas scattered throughout a chat, developers can work from a structured roadmap that can be revised, shared, and reused.

5. Long-term value: Plans can evolve into the engine of the entire project

Many users initially adopt Plan Mode to make coding safer.

Over time, they discover it’s just as useful for documentation.

Because plans are structured markdown artifacts, they naturally evolve into:

• Feature roadmaps
• Migration checklists
• Implementation specifications
• Architecture reviews
• Onboarding documents

In many cases, the plan itself becomes the most valuable output. Even if implementation never happens, the document captures a deep understanding of the system and a clear strategy for future work.

The real purpose of Plan Mode isn’t preventing Claude from writing code.

It’s separating thinking from doing.

By combining a planning-focused workflow, a dedicated exploration subagent, hard platform-level restrictions, and persistent planning artifacts, Claude Code creates an environment where analysis comes before execution — which ends up dramatically improving the quality of the execution.

Yes Claude Code by itself is pretty good — but the default setup only scratches the surface of what it can do.

Extending it with plugins takes you to a whole different level as a developer.

Plugins are a new way to upgrade Claude Code with many valuable capabilities, like:

• Crucial cost-saving automations and skills
• Deeper code understanding for greater accuracy and code quality
• Essential external integrations — with your repos, databases, dev tools, and so much more.

They all work together to elevate Claude Code into an more capable development partner that levels up your productivity.

1. GitHub integration — Connect Claude directly to your repository workflow

The GitHub plugin brings your repository workflow directly into your terminal — allowing Claude to work with issues, pull requests, and commits without manual context switching.

Instead of copying issue descriptions, PR links, or code snippets into Claude, you can ask it to investigate and act directly within your GitHub workflow.

Official Package: github

Install:

/plugin install github@claude-plugins-official

Key Features:

• Issue Triage: Ask Claude to analyze issues and implement fixes directly from issue references.
• Pull Request Support: Generate PR descriptions, review incoming diffs, and push commits to branches.
• Repository Search: Search code, commits, and history across your organization’s repositories.
• Git Workflow Assistance: Understand branch changes and help prepare code for review.

2. Feature Dev — Plan, build, and review features with confidence

Feature Dev is Anthropic’s official plugin for building software features with a structured, end-to-end workflow.

It guides Claude through codebase exploration, architecture planning, implementation, and review — instead of jumping straight into coding.

Official package

feature-dev@claude-plugins-official

Official installation

/plugin install feature-dev@claude-plugins-official

Key features

• Guided 7-phase development workflow
• Specialized exploration, architecture, and review agents
• /feature-dev command for end-to-end implementation
• Architecture-first approach before coding

3. LSP plugins — give Claude IDE-level code intelligence

LSP plugins transform Claude from a text-based coding assistant into a tool with deeper understanding of your programming language and codebase structure.

Without Language Server Protocol (LSP) integration, AI agents primarily understand code as plain text. LSP plugins connect Claude Code to language servers, giving it access to the same type of intelligence modern IDEs provide.

Official package: typescript-lsp, pyright-lsp, gopls-lsp, rust-analyzer-lsp

Install:

/plugin install typescript-lsp@claude-plugins-official

Key features:

• Project-Wide Navigation: Understand symbols, references, definitions, and relationships across large codebases.
• Jump-to-Definition Support: Trace functions, classes, and variables throughout your application.
• Real-Time Diagnostics: Detect compiler errors, type issues, and broken imports after edits.
• Reduced Hallucinations: Prevent incorrect function signatures and invalid API assumptions.

4. Frontend Design — Make every UI look professionally designed

Frontend Design helps Claude generate polished, production-ready interfaces with modern UI and UX practices.

It automatically applies better layouts, typography, spacing, and visual hierarchy to create designs that avoid generic AI aesthetics.

Official package

frontend-design@claude-plugins-official

Official installation

/plugin install frontend-design@claude-plugins-official

Key features

• Generates production-quality interfaces
• Applies modern UI and UX best practices
• Creates responsive, design-system-aware layouts
• Auto-invokes during frontend development

5. CLAUDE.md Management — Help Claude remember your project correctly

CLAUDE.md Management helps keep your project’s CLAUDE.md accurate as your codebase evolves.

It audits project instructions, updates outdated guidance, and captures new knowledge so Claude always has reliable project context.

Official package

claude-md-management@claude-plugins-official

Official installation

/plugin install claude-md-management@claude-plugins-official

Key features

• Audits and improves CLAUDE.md files
• Updates project guidance automatically
• Captures learnings from development sessions
• Preserves accurate project memory