Cook up better AI agents for Claude Code

Ever tried to get Claude to consistently act like a senior Rust engineer, only to watch it forget halfway through your conversation? Or maybe you've spent hours crafting the perfect prompt for code reviews, just to lose it in your chat history? Yeah, we've been there too.

Here's the thing: Claude Code subagents are like having a team of specialized developers on standby, each one laser-focused on their domain. But most developers don't know you can create your own custom agents tailored to your exact needs. Today, we're sharing our battle-tested recipe for cooking up subagents that actually deliver.

The Secret Sauce: Job Descriptions

Here's the counterintuitive part: the best way to create a technical AI assistant is to write a job description for it. Think about it. Job descriptions already capture exactly what you need: required skills, experience level, specific expertise, and expected deliverables. They're literally specifications for human intelligence, which makes them perfect blueprints for AI agents.

We've refined this process down to four simple steps that consistently produce production-ready subagents. No complex prompt engineering. No trial and error. Just a systematic approach that works every time.

The Four-Step Recipe

Step 1: Generate the Job Description

Fire up your favorite LLM (Claude, ChatGPT, or Mistral all work great) and ask it to create a job description for your ideal specialist. Be specific about the role and expertise you need.

Example prompt:

Create a detailed job description for a Staff Software Engineer 
who specializes in Rust systems programming, with particular 
expertise in async Rust and performance optimization.

The LLM will generate a standard job posting with sections like responsibilities, requirements, and qualifications. This is your foundation.

Step 2: Refine and Expand

This is where you turn a generic job description into your specialized agent blueprint. Push the LLM to be more specific about the skills you actually need.

Refinement prompts:

Expand on the technical requirements. This engineer should be 
an expert in:
- Async Rust patterns with tokio
- Zero-copy networking
- Lock-free data structures
- Memory profiling and optimization

Add more detail about their experience with production systems 
handling millions of requests per second.

Don't be shy here. The more specific you are about the expertise, the better your subagent will perform. If you need someone who can optimize SIMD operations in Rust, say so. If they should understand WebAssembly compilation, add it.

Step 3: Strip the Fluff

Job descriptions come with a lot of corporate padding that your subagent doesn't need. Remove sections like:

• "What We Offer" (your AI doesn't care about vacation days)
• "About Our Company" (irrelevant for the agent)
• "Equal Opportunity Statement" (your AI doesn't discriminate anyway)
• Generic soft skills (unless specifically relevant to the task)

Keep only the meat: technical requirements, specific expertise, problem-solving approaches, and expected deliverables.

Step 4: Transform into a Subagent

Now for the magic. Take your refined job description and an example subagent (like our Rust architect from the awesome-claude-subagents collection), and feed them to your LLM with this prompt:

Create a Claude Code subagent based on this job description. Use the provided subagent as a guide.

If you need to understand what a subagent is, check out the 
docs here: https://docs.anthropic.com/en/docs/claude-code/sub-agents

[PASTE YOUR JOB DESCRIPTION]

Here's an example of a well-structured subagent for reference:
[PASTE EXAMPLE SUBAGENT]

The LLM will generate a complete subagent configuration with the proper YAML frontmatter and detailed personality instructions.

Pro Tips from the Kitchen

Choose Your Model Wisely: The model parameter in your subagent YAML matters. Use opus for complex reasoning tasks, sonnet for balanced performance, and haiku for simple, fast operations. Don't default to the most expensive option - match the model to the task complexity.

Test with Real Problems: Once you've created your subagent, throw actual problems at it immediately. Debug a real Rust lifetime issue. Have it review actual code. The faster you validate it against real work, the quicker you'll identify what needs tweaking.

Iterate on Specificity: If your subagent is too generic, go back to step 2 and add more specific requirements. The difference between "knows TypeScript" and "expert in TypeScript type gymnastics, conditional types, and template literal types" is massive in practice.

Keep Your Best Recipes: When you create a subagent that really delivers, save it. Build your own collection. Share it with your team. These aren't one-off prompts - they're reusable tools that get better with refinement.

Why This Works

Job descriptions are already optimized for communicating capability requirements. They're structured, comprehensive, and focused on outcomes. By leveraging this existing format, you skip the painful process of figuring out how to structure your prompt from scratch.

More importantly, thinking in terms of "hiring" a specialist forces you to be specific about what you actually need. You wouldn't hire a "programmer" - you'd hire a "Senior Backend Engineer with GraphQL and PostgreSQL expertise." That specificity translates directly into more effective AI agents.

The Reality Check

Let's be crystal clear: subagents aren't replacing your engineering skills. They're force multipliers for engineers who know what they're doing. Use them to handle repetitive tasks, get specialized perspectives, or accelerate prototyping. But always review the output, understand what's being generated, and maintain your core engineering judgment.

The best engineers aren't those who avoid AI tools - they're the ones who wield them effectively while maintaining their technical edge. Think of subagents as really smart autocomplete, not autopilot.

Start Cooking

Ready to build your own specialized AI team? Start with one specific pain point in your workflow. Maybe it's writing comprehensive tests, optimizing database queries, or reviewing TypeScript types. Create a subagent for that one task and see how it performs.

Once you taste the productivity boost of a well-crafted subagent, you'll never go back to generic prompts. Your future self (and your team) will thank you for taking the time to build these specialized tools now.

The kitchen is open. Time to start cooking up some subagents.

Want to see more battle-tested subagents? Check out our curated collection of production-ready agents for TypeScript, Rust, and more.