DEV Community: Anjith Paila

Github Copilot Best Practices: From Good to Great

Anjith Paila — Wed, 28 Jan 2026 00:29:11 +0000

Introduction
Part 1: Fundamentals
- 1.1 Context is everything
- 1.2 Prompt Engineering Essentials
- 1.3 Chat and Inline Completions
Part 2: Daily Workflow Optimisation
- 2.1 Shortcuts & Speed Tricks
- 2.2 Custom Instructions
Part 3: Security & Quality
- 3.1 Do not over rely
- 3.2 Always review parameterised queries
- 3.3 Verify input validation exists
- 3.4 Ensure proper error handling
- 3.5 Check that secrets come from environment variables
- 3.6 Context Mismanagement
Summary

Introduction

This guide assumes you already know the basics: you've installed Copilot, understand tab-to-accept, and you've seen inline completions in action. Now it's time to take one level up. We'll explore techniques that transform Copilot from a simple autocomplete tool into a useful pair programming partner. We will be looking at some code examples to demonstrate the features. Clone the following git repository and open in any copilot supported IDE.

git clone git@github.com:anjithp/ai-code-assistant-demo.git

Part 1: Fundamentals

1.1 Context is everything

The single most important factor in getting quality suggestions from Copilot isn't your prompts: it's your context. Copilot may process all open files in your IDE to understand your codebase patterns.

What this means in practice:

When working on a feature, open all relevant files. For example, If you're building a new React component that fetches tasks from an API, open:

The component file you're creating
The API service file
The TypeScript types file
An existing similar component as a reference

What to close:

Close files that aren't relevant to your current task. If you have 20 tabs open from yesterday's debugging session, Copilot's attention is diluted across irrelevant context. Each open file consumes Copilot's limited context window.

Example: Building a task service

Let's say you need to create a new service method in our example project. Here's how context changes the outcome:

Poor context (only taskService.ts open):

// Copilot may suggest generic CRUD code

export const getTaskById = async (id: number) => {
  // Generic suggestion without your patterns
}

Rich context (open taskService.ts, Task.ts model, Category.ts model, and existing similar service):

// Copilot suggests code matching your exact patterns

export const getTaskById = async (id: number) => {
  return await Task.findByPk(id, {
    include: [
      {
        model: Category,
        as: 'category',
        attributes: ['id', 'name', 'color']
      }
    ]
  });
};

The second suggestion matches your project's Sequelize patterns, includes the relationship you always load, and follows your naming conventions: all because Copilot had the right context.

1.2 Prompt Engineering Essentials

After context, the next most important thing to get good results is prompts. The best prompts follow the 3S Principle: Specific, Simple, Short.

Specific: Tell Copilot exactly what you need. Include precise details like desired output format, constraints, or examples. This guides Copilot toward relevant suggestions rather than generic ones.

❌ Bad:

Create a hook

✅ Good:

Custom React hook to fetch and manage tasks with loading and error states.
Returns tasks array, loading boolean, error string, and CRUD methods

Simple: Break complex tasks into smaller steps. Use straightforward language without unnecessary jargon or complexity. Focus on the core intent to make it easy for the AI to understand and respond.

Instead of: "Create a complete authentication system with JWT, refresh tokens, and role-based access control"

Break it down:

Step 1: Create JWT token generation function
Step 2: Create token verification middleware
Step 3: Create refresh token rotation logic

Short: Keep prompts concise to maintain focus: aim for brevity while covering essentials, as longer prompts can dilute the copilot's attention.

❌ Too verbose:

This function should take a task object and update it in the database
but first it needs to validate the task data and make sure all the fields
are correct and if anything is wrong it should throw an error...

✅ Concise:

// Validates and updates task, throws on invalid data
export const updateTask = async (id: number, data: Partial<TaskData>) => {

In summary, keep the prompts as specific to the task in hand, break down when necessary and be concise to the point.

Write detailed comments above function signatures

Comments directly above where you're writing code have the strongest influence on Copilot's suggestions. A well-written comment acts as a specification. It tells Copilot not just what the function does, but how it should behave, what it should return, and any important implementation details.

// Retrieves a single task by ID with associated category
// Returns null if task doesn't exist
// Includes category with id, name, color fields only

export const getTaskById = async (id: number) => {
  return await Task.findByPk(id, {
    include: [
      {
        model: Category,
        as: 'category',
        attributes: ['id', 'name', 'color']
      }
    ]
  });
};

Use inline examples to establish patterns

One of the most effective prompting techniques is showing an example, then letting it generate similar code. This is particularly useful when you're writing repetitive code with slight variations like filter conditions, validation rules, or similar data transformations.

Write the first example manually, add a comment indicating you want more like it, and Copilot will follow the pattern.

// Example: status filter
if (filters.status) {
  where.status = filters.status;
}

// Now generate similar code for priority, categoryId
if (filters.priority) {
  where.priority = filters.priority;  // Copilot follows the pattern
}

if (filters.categoryId) {
  where.categoryId = filters.categoryId;
}

Write test descriptions first in TDD

This could be a good trick if you follow TDD in your development workflow. Test-Driven Development works really well with Copilot. When you write your test first, describing what the function should do and what you expect, Copilot can then generate an implementation that satisfies that specification.

The test acts as both a specification and a validation. Copilot sees what behavior you're testing for and suggests code that produces the expected results.

describe('getTaskStatistics', () => {
  it('should return correct task counts by status', async () => {
    // Arrange: Create 4 tasks (2 pending, 1 in progress, 1 completed)
    // Act: Call getTaskStatistics()
    // Assert: Verify counts match
  });
});

// Now type the implementation. Copilot will suggest code that satisfies this test

1.3 Chat and Inline Completions

Use Inline Completions when:

Writing straightforward code with clear patterns
Completing functions where the signature gives clear picture of what needs to be done
Generating boilerplate code
You know exactly what you need

Use Copilot Chat when:

You need to understand existing code
Refactoring complex logic
Debugging errors
Exploring multiple approaches
Working across multiple files

Use @workspace for codebase-wide questions

The @workspace participant tells Copilot to search your entire codebase to answer a question. This is incredibly useful when you're trying to understand how something works across your project, find where a pattern is used, or locate specific functionality. Instead of using grep or manually searching, ask Copilot to find and explain patterns for you.

Use /explain before /fix when debugging

When you encounter a bug, the temptation is to immediately ask Copilot to fix it. However, using /explain first helps you understand the root cause, which leads to better fixes and helps you learn from the issue.

Powerful Chat Features:

Slash commands are shortcuts to common tasks:

/explain – Get a breakdown of complex code
/fix – Debug and fix errors
/tests – Generate test cases
/doc – Create documentation

Chat participants give Copilot specific context:

@workspace – Search across your entire workspace
#file – Reference specific files: "Update #taskService.ts to use async/await"
#codebase – Let Copilot search for the right files automatically

Example chat prompts:

@workspace how do we handle authentication in this codebase?
Show me where JWT tokens are verified.

/explain why is this causing an infinite re-render?
[After understanding the issue]
/fix update the dependency array to prevent re-renders

Part 2: Daily Workflow Optimisation

2.1 Shortcuts & Speed Tricks

Essential shortcuts (VS Code)

Tab : Accept suggestion
Esc : Dismiss suggestion
Ctrl+Enter (Windows/Linux) / Cmd+Enter (Mac) : Open Copilot Chat
Alt+] : Next suggestion
Alt+[ : Previous suggestion
Ctrl+→ : Accept next word of suggestion

Multiple conversation threads

You can have multiple ongoing conversations by clicking the + sign in the chat interface. Use this to:

Keep a debugging conversation separate from a feature discussion
Maintain context for different tasks
Avoid polluting one conversation with unrelated context

Quick accept/reject pattern

When a suggestion is 70-80% correct, it's often faster to accept it and make small edits than to reject it and prompt again. This iterative approach is faster and more productive than waiting for perfect suggestions.

See suggestion → Quickly evaluate (2-3 seconds max)
If 80% correct → Accept with Tab, then edit
If wrong direction → Esc and add clarifying comment
If close but not quite → Alt+] to see alternatives

Build a personal library of effective prompts

As you work with Copilot, you'll discover prompts that consistently produce good results for your codebase. Keep a document with these prompts so you can reuse them. This library becomes more valuable over time as you refine prompts for your specific patterns and needs.

2.2 Custom Instructions

Custom instructions let you teach Copilot your preferences and coding standards. Project-level instructions should be saved in the file .github/copilot-instructions.md. This file acts as a project-wide instruction manual that Copilot reads automatically. It's where you document your tech stack, coding patterns, testing conventions, and any project-specific rules. Think of it as onboarding documentation for Copilot.

Tip: For existing projects, you can put copilot in agent mode, ask it to generate initial instructions file by scanning the repo and make necessary modifications manually.

Example:

# Project Instructions

## Tech Stack
- Backend: Express.js + TypeScript + Sequelize + SQLite
- Frontend: React 19 + TypeScript + Vite

## Code Patterns
- Use functional programming style for services
- All async functions use async/await (never callbacks)
- Services contain business logic, controllers handle HTTP only
- Always include JSDoc comments for exported functions
- Use explicit return types in TypeScript

## Testing
- Tests in `tests/` directory mirror `src/` structure
- Use descriptive test names: "should return 404 when task not found"
- Mock database calls with jest.mock()

## Error Handling
- Controllers throw ApiError for HTTP errors
- Services throw Error with descriptive messages
- Validation errors should specify which field failed

Part 3: Security & Quality

3.1 Do not over rely

The biggest mistake is accepting code you don't understand. Every accepted suggestion should pass this test: "Could I have written this myself given time?" If the answer is no, you're accumulating technical debt or worse critical production incident. In my personal experience, AI assistants have generated buggy and unsafe code several times. Though this is improving you should still be the ultimate judge of the overall quality.

When to write code yourself:

Complex business logic unique to your domain
Security-critical authentication/authorization
Performance-sensitive algorithms
Cryptography implementations

3.2 Always review parameterised queries

SQL injection is one of the most common and dangerous security vulnerabilities. While modern ORMs like Sequelize protect you by default, Copilot might occasionally suggest raw queries or string concatenation. Always verify that database queries use parameterized inputs, never string interpolation.

// ❌ Dangerous - SQL injection vulnerability
const tasks = await sequelize.query(
  `SELECT * FROM tasks WHERE status = '${status}'`
);

// ✅ Safe - parameterized query
const tasks = await Task.findAll({
  where: { status }
});

3.3 Verify input validation exists

User input should always be validated before being used in business logic or database operations. Copilot may not always add comprehensive validation, so check that suggested code validates required fields, data types, string lengths, and formats. Missing validation can lead to data corruption, application crashes, or security issues.

export const validateTaskData = (data: Partial<TaskCreationAttributes>) => {
  // Make sure Copilot added proper validation
  if (data.title !== undefined) {
    if (data.title.trim().length < 3) {
      throw new Error('Title must be at least 3 characters long');
    }
  }
  // Check that all required validations are present
};

3.4 Ensure proper error handling

HTTP endpoints should have try-catch blocks(or common error handlers) to handle errors gracefully and return appropriate HTTP status codes. Copilot sometimes generates the happy path without error handling, so always verify that exceptions are caught and handled. Unhandled exceptions crash your server or return 500 errors without useful information.

export const createTask = async (req: Request, res: Response) => {
  try {  // Verify Copilot added error handling
    const task = await taskService.createTask(req.body);
    res.status(201).json({ success: true, data: task });
  } catch (error) {
    // Proper error handling should be here
  }
};

3.5 Check that secrets come from environment variables

Hardcoded secrets in source code are a critical security vulnerability. API keys, database passwords, and JWT secrets must come from environment variables, never be written directly in code. Copilot might suggest hardcoded values for convenience so always replace them with environment variable references.

// ❌ Never accept hardcoded secrets
const secret = 'abc123...';

// ✅ Always use environment variables
const secret = process.env.JWT_SECRET;
if (!secret) {
  throw new Error('JWT_SECRET not configured');
}

3.6 Context Mismanagement

Too many irrelevant files:

Close files from previous tasks. Copilot's context window is limited so better to have only relevant files open.

Not enough context:

Open related files even if you're not editing them. That type definition file, that similar component, they all help to get quality suggestions.

Ignoring project patterns:

If you have a unique architecture or patterns, document them in .github/copilot-instructions.md. Don't expect Copilot to guess.

Summary

Copilot is a powerful tool, but you're still the developer and should have the final say about the code going into production. If you remember the following tips you will go a long way in getting the most value of copilot or any other AI coding assistant.

Manage context – relevant files open, irrelevant files closed
Write clear, specific prompts – following the 3S principle or any other prompting pattern
Use the right tool for the job – chat for exploration, inline for completion
Never blindly accept – every suggestion should be reviewed and understood
Teach patterns – through custom instructions and documentation

Introduction to Claude Code

Anjith Paila — Thu, 20 Nov 2025 02:15:11 +0000

What is Claude Code?
Key Capabilities?
What should you use Claude Code for?
How Claude Code works under the hood?
Installation and Setup
Getting Started
Feature Development
Bug Fixing
Testing
Subagents
Slash commands and scripting
Conclusion

What is Claude Code?

Claude Code is a command-line tool from Anthropic that brings Claude's AI capabilities directly into your terminal, enabling autonomous coding assistance through natural language commands. Unlike traditional IDE plugins or web-based AI assistants, Claude Code operates as a standalone CLI application that can read, write, and modify files in your codebase while maintaining full context of your project structure.

At its core, Claude Code follows a simple workflow:

bash

# You describe what you want in plain English

claude "refactor this authentication module to use JWT tokens"

# Claude analyzes your codebase, makes changes, and explains what it did

Plenty of coding agents are already out there, and most of them offer the same core functions: navigating codebases, generating and refining code, executing commands, handling git workflows, and juggling multiple development threads at once.

So, what sets Claude Code apart?

Key Capabilities

Terminal-Based Architecture

Claude Code lives in your terminal, making it accessible via SSH, scriptable in CI/CD pipelines, and usable across any development environment without GUI dependencies. Other cli based coding agents have entered into the market now like cursor cli and likely others will follow soon.

Action-Taking Capabilities

Rather than just suggesting code, Claude Code actively performs tasks such as:

Creates new files and directories
Modifies existing code with precision
Runs tests and interprets results
Manages git operations when needed

Unix Philosophy in Action

Claude Code embodies "do one thing well" - it's a focused tool that integrates seamlessly with pipes, scripts, and other command-line utilities. This seamless integration in the command line makes it very powerful to write scripts and automate tasks.

bash

# Combine with other tools
git diff | claude "explain these changes"

# Find TODOs and address them
grep -r "TODO" . | claude "implement these todos"

Direct File Editing

No copy-paste workflow needed. Claude Code lives in your repository, reads your actual files, understands their relationships, and makes changes in place:

bash

# Claude sees your entire module structure

claude "add error handling to all API endpoints in src/api/"

# Files are modified directly, ready for git diff review

This direct manipulation approach means you stay in your terminal, maintain your flow state, and can immediately test or commit changes without context switching between applications.

Enterprise-Ready Design

Built with professional development in mind:
Respects .gitignore and project boundaries
Supports team-wide configuration standards using cluade.md files.
Integrates with existing security policies and is based on permission based architecture with read only as default.

What should you use Claude Code for?

Develop features and fix Bugs

Explain what you would like to do in a prompt, and Claude Code will create a detailed plan and will write the code. Claude Code can also interpret error messages or describe what’s going wrong and will diagnose the issue in your codebase, pinpoint the cause, and apply the right fix. As with any AI tool, a clear and structured prompting yields good results.

bash

# Generate boilerplate code and project structures from scratch:
claude "create a Node.js REST API with JWT auth and user CRUD operations"

# Scaffold test suites
claude "generate unit tests for all services in src/services/"

# Systematic changes across multiple files:
claude "refactor all database queries to use async/await pattern"

# Fix failing tests
claude "fix the failing Jest tests in user.test.js"

# Debug error traces
cat error.log | claude "diagnose and fix this production error"

# Generate comprehensive docs
claude "document all public APIs with JSDoc comments"
claude "generate README with setup instructions based on package.json"

Explore and Understand Your Codebase

Whether you’re diving into a massive legacy system or a fresh project, Claude Code tries its best to provide clear answers about structure, logic, and dependencies. It stays aware of the full project, pulls in updates from the web, and can even connect to tools like Google Drive, Figma, and Slack for additional context using MCP servers.

Task Complexity Sweet Spot

Claude Code works best with tasks that are:

Well-defined but tedious to implement manually
Require understanding of multiple files and their relationships
Follow established patterns in your codebase
Can be verified through tests or linting
The key is finding the balance between tasks that are too simple (faster to do manually) and too complex (require human judgment and iteration).

How Claude Code works under the hood?

Assistants like Claude Code and others have similar working principles under the hood. Please checkout this article https://anjith.tech/2025/09/12/how-coding-assistants-work/ to learn more.

Installation and Setup

Linux/macOS/WSL

Claude Code needs npm to install. First install Node.js 18+ https://nodejs.org/en/download. After this run the following command to install claude code globally.

npm install -g @anthropic-ai/claude-code

Another way to install natively is by running the following command

curl -fsSL https://claude.ai/install.sh | bash

Windows

Claude Code is built as a command-line tool designed for Unix-like operating systems so windows needs a special treatment and is a bit more involved. First we need to install wsl(Windows Subsystem for Linux) as a precursor. Open PowerShell as Administrator and execute:

wsl --install

After this reboot the system for the installation to take an effect, launch the installed Linux distribution from the start menu and create a new user account and password when prompted. Now follow the steps in Linux/macOS to proceed with claude code installation.

Alternative way to install natively using power shell is by running the below command

irm https://claude.ai/install.ps1 | iex

There are several subscription options to get access to claude code. Refer https://www.claude.com/pricing for more details. It is also possible to use API key based approach using Anthropic console account(https://console.anthropic.com/). If you choose this option, an environment variable ANTHROPIC_API_KEY="your-api-key-here" should be added to your environment depending on the operating system manually or just initiate login command and choose Anthropic console account and authorise the login. Please be aware of the costs when using API key as the costs may spiral out if not careful. My recommendation is to use pro or max account depending on the usage level. You can start the login as below:

claude

# You'll be prompted to log in on first use
# Or

/login
# Follow the prompts to log in with your account

Once logged in, your credentials are stored and you may not need to login again.

IDE Integration

Claude Code is primarily a CLI based tool but if you want to see the changes done visually then you can install relevant extension/plugin for your IDE.

VSCode: https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code
JetBrains IDEs: https://plugins.jetbrains.com/plugin/27310-claude-code-beta-

Getting Started

Let’s explore Claude Code with a hands-on example. Follow these steps:

Clone the repository(https://github.com/anjithp/ai-code-assistant-demo).
Navigate to the quick-start directory and follow the build instructions in the README.
Launch the application.

The project uses TypeScript, Node.js, and React. If you’re comfortable with basic programming concepts, you’ll be able to follow along easily. Once running, your app should look like this:

Initializing Your Project

Start by initializing Claude Code in your project:

Navigate to the quick-start directory in your terminal.
Run the Cluade CLI with the command: claude
Execute the init command: /init

Claude scans your codebase and generates claude.md: a project memory file that describes your repository’s structure, purpose, and key components.

Review and Refine

Review the generated file carefully. Claude uses claude.md as context for all tasks, so accuracy matters. Check that it correctly describes your project, then:

Add any missing details
Fix any inaccuracies
Commit claude.md to version control

This ensures your entire team works with the same project context.

Understanding the project

Prompt: What does this project do? Give me an overview of the architecture.

When you ask Claude about your project Claude will:

Read relevant project files
Identify the technologies and frameworks used
Explain core functionality (like CRUD operations)
Map out how components communicate (frontend-to-backend flow)

Claude may need to run commands(tools) to gather information. For example, it might ask permission to:

Run tree to explore your directory structure
Execute other diagnostic commands

You’ll be prompted to approve these actions before they run.

When Claude requests permission to run a command, you have three options:

Allow once – Run the command this time only
Always allow – Run this command now and in future sessions without asking
Deny/Do differently – Block the command or suggest an alternative approach

Before approving, verify:

The command is safe to execute
It’s running with correct parameters
It won’t modify or delete important files

If a command looks unsafe or incorrect, choose option 3 to deny it or propose a different approach.

Finding Specific Code and Patterns

Claude Code can trace logic flows and identify patterns across your entire codebase.

Ask questions like: “Where is the task creation logic implemented?” Claude will analyze your codebase and show the complete flow:

UI layer → State management → Routing → Controller → Service → Model

Ask questions like: “What programming patterns are used in this codebase?”

Claude will identify architectural and design patterns such as:

MVC, Repository, or Factory patterns
State management approaches
API design patterns

This helps you understand existing conventions and maintain consistency when adding new features.

Feature Development

Let’s walk through real-world examples of how to use Claude Code to add new features to your codebase.

Adding a New Task Priority

Prompt: 

Implement code to add a new task priority called "Critical".

Requirements:

1. Add "Critical" to the default priorities that are seeded in the database
2. Ensure the priority appears in the frontend priority filter dropdown
3. priority label color in tasks view frontend should be #a70606ff
3. The priority should work with all existing task operations (create, update, filter)
4. No need to implement tests
5. Use existing patterns

How Claude Code Responds:

Analyzes requirements and creates a TODO plan listing all necessary changes
Requests permission to start making edits

Permission Options:

Allow one-by-one – Review each file change individually
Allow all edits this session – Let Claude make all changes at once (recommended for simple tasks like this)

After Completion:

Claude shows a summary of all changes made. You can then verify the new “Critical” priority appears and works correctly in your UI.

Adding User Authentication

Adding user authentication is more complex than adding a task priority: it requires changes across multiple layers of your application. For tasks like this, use Plan Mode to map out the solution before writing any code. This feature should be used in scenarios such as requiring changes across many files, researching the codebase before making changes, iterating on the approach with Claude before committing etc.

Switching to Plan Mode:

Claude Code has three modes, toggled with Shift+Tab:

Normal Mode (default) – Prompts for permission on each change
Auto-Accept Mode – ⏵⏵ accept edits on – Automatically applies all edits
Plan Mode – ⏸ plan mode on – Creates plans without making changes

To Enter Plan Mode:

From Normal Mode: Press Shift+Tab → Auto-Accept Mode
Press Shift+Tab again → Plan Mode

Prompt:

Add JWT-based user authentication to the task management app.

Requirements:

- Each user should only see their own tasks
- Use JWT tokens
- Store JWT token in localStorage with auto-login on page refresh
- Build login and register forms in the frontend
- Protect task routes and redirect to login if not authenticated
- No need of any tests

Claude analyzes your codebase and generates a detailed implementation plan showing:

All files that need to be created or modified
The sequence of changes required
How components will interact

After reviewing the plan, you can either manually approve the changes one-by-one or auto-accept all edits at once. Below is the snapshot how the plan looked like when I tried.

After working through the plan, Claude Code successfully implemented the entire login feature. The authentication system worked immediately: no debugging, no fixes needed.

This demonstrates Claude Code’s ability to:

Understand complex, multi-file changes
Follow existing code patterns consistently
Integrate new features without breaking existing functionality
Deliver working code on the first attempt(sometimes)
Power of using Plan Mode for complex features

The examples above used simple prompts for brevity, but you should make yours specific and context rich. The richer your context, the better Claude Code understands your requirements and architectural preferences.

Disabling Permission Checks

If permission prompts become disruptive, you can launch Claude Code without them:

# use with extreme caution
claude --dangerously-skip-permissions

Only use this flag when you fully understand the risks. Without permission checks, Claude Code could:


Delete unintended files
Make incorrect git commits
Modify critical configuration files
Execute potentially harmful commands

When to Consider This Flag:

You’re working in a safe, isolated environment
You have recent backups
You’re performing repetitive, well-understood tasks

Bug Fixing

To effectively fix bugs, instruct the steps to reproduce the issue and give stack trace and mention if the bug is intermittent or consistent. To simulate let’s manually introduce a bug and see whether claude can figure it out. Make the following changes to countByStatus method in taskService.ts file in the backend.

 return tasks.filter(task => task.status = status).length;

We mistakenly put = operator instead of equality operator(===). Now create one or more tasks and refresh the UI and you can see that the dashboard shows same number of tasks for all statuses which is incorrect.

Prompt:

On dashboard same number of tasks shown for pending, in progress and completed cards despite having tasks in different status in the db. Find and fix the issue.

Claude Code traces the flow from frontend to backend and identifies the assignment operator (=) should be an equality operator (===).

Let’s try to fix another subtle bug. Create task with some category other than ‘None’ and now update the task to remove the category by selecting ‘None’. You will notice that category doesn’t get removed.

Prompt:

While updating the task, setting category to None doesn't result in the category getting removed from the task and the old category is still retained. Fix this issue.

On my first attempt, Claude didn’t make the correct fix. After a follow-up prompt clarifying the issue persisted, it identified the root cause:

categoryId was typed as number | undefined
When serialized to JSON, undefined properties get removed
Solution: Change type to number | null and send null when category is removed

Key Takeaway:

Sometimes you need iterative prompts with additional context to reach the correct solution. Don’t expect perfection on the first try: treat it as a conversation where you provide more details as needed.

Testing

Code assistants excel at generating tests. You can request unit tests, integration tests, edge case scenarios, or tests in specific styles (like BDD).

Prompt:

Write integraion tests for taskService.ts module in backend using jest library.
- Use BDD style for test names.
- Use in memory database.
- Cover edge cases and error scenarios

How Claude Code Responds:

Generates comprehensive tests covering all service methods
Asks permission to run the tests for verification

What to Expect:

Tests may not pass on the first attempt. Claude Code will:

Read error messages
Make necessary corrections
Iterate until tests succeed

This may take several attempts, which is normal. If your repo already has test cases, improve results by instructing Claude to follow patterns. For example like below:

Write integration tests for taskService.ts following existing test patterns.
Use the same structure and conventions as tests/userService.test.ts

Providing sample test files in the context helps Claude match:

Your naming conventions
Setup/teardown patterns
Assertion styles
Mock patterns

This ensures consistency across your test suite.

Subagents

Subagents are specialized AI assistants you create to handle specific tasks and they let you delegate specialized work while maintaining clean separation of concerns: similar to how you’d assign specific responsibilities to different team members. You can think of them like custom and polished prompts with following extra features:

Independent Context Window

Each subagent has its own separate context
Their work doesn’t clutter your main conversation
Keeps your primary agent focused on the overall task

Custom System Prompts

Define each subagent’s personality and expertise
Example: One subagent acts as a strict code reviewer, another generates creative test cases
Tailor instructions to specific roles

Scoped Tool Access

Grant subagents only the tools they need
Improves security by limiting capabilities
Keeps agents focused without distractions from unnecessary commands

Reusability

Create once and use across different projects
Helps bring consistent workflows

Let’s create a subagent that reviews code like a senior developer.

Launch the agent creator: Run /agents command
Create new agent: Select ‘Create New Agent’
Set scope: Choose ‘Project’ (available to all team members)
Generation method: Select ‘Generate with Claude’
Define the role: Enter "Review code as a senior developer"
Grant permissions: Choose ‘All Tools’ (or select specific tools)
Customize appearance: Select model and background color
Review and save: Read the generated description, then save or edit before saving

To use the sub agent, make some code changes, then invoke your subagent:

Use senior-code-reviewer subagent to check my uncommitted changes.

The subagent will review your changes with the perspective and standards of a senior developer, providing focused feedback without cluttering your main conversation. The code review subagent is just one example. You can create specialized subagents for scenarios like:

Documentation writer – Generates comprehensive docs from code
Security reviewer – Focuses exclusively on security vulnerabilities
Debugging specialist – Traces and diagnoses complex bugs
Performance optimizer – Identifies bottlenecks and suggests improvements
Test generator – Creates comprehensive test suites
API designer – Reviews and suggests API improvements

Community Resources:

Check out this curated list of subagent examples: https://github.com/VoltAgent/awesome-claude-code-subagents You can use these subagents as-is or customize them to match your team’s specific needs and standards.

If you want to create your own sub agents, follow the below guidelines.

Keep subagents focused on a single job. The best subagents are specialists, not generalists. A dedicated code-reviewer outperforms an agent trying to review code, write tests, and update documentation. Focused agents are more reliable and easier to manage and produce better results.
Write clear, detailed system prompts. Your subagent’s effectiveness depends entirely on its system prompt quality. Include step-by-step processes, define explicit rules, specify coding standards and patterns to follow etc.

Bad Prompt:

Review code for issues

Good Prompt:

Review code as a senior developer focusing on:

- Security vulnerabilities such as SQL injection, XSS, auth issues
- Performance bottlenecks such as N+1 queries, memory leaks
- Code maintainability (naming, complexity, duplication)
- Follow existing project patterns in /src/patterns/
- Prioritize critical issues over style preferences

Slash commands and scripting

Claude Code’s command-line interface includes slash commands: shortcuts that start with / to run pre-defined tasks without writing lengthy prompts. Let’s look at some essential slash commands.

Session Management:

/clear – Clears conversation history and frees up context (use when starting fresh)
/compact – Clears history but keeps summary in context (prevents hitting token limits)
/rewind – Restores conversation to a previous point (useful when suggestions go off-track)
/exit – Exits the REPL

Cost & Context:

/cost – Shows total session cost (tracks API charges)
/context – Visualizes current context in a colored grid

Account & Configuration:

/login, /logout – Manage Anthropic account authentication
/model – Switch between models (Opus, Sonnet, etc.)
/memory – Edit project and user memory files (claude.md)

Workflows:

/review – Reviews a pull request
/export – Exports conversation to file or clipboard

While using Claude Code, you can make ad-hoc suggestions like “add this to memory” and Claude will update claude.md accordingly. These are the most commonly used commands. Check the Claude Code documentation for the complete list of built-in commands.

Creating Custom Slash Commands

You can create your own slash commands at both project and user levels.

Project commands (.claude/commands/) – Available to everyone who clones the repository
User commands (~/.claude/commands/) – Personal commands only you can use

Create the commands directory:

# For project-level commands
mkdir -p .claude/commands

# For user-level commands
mkdir -p ~/.claude/commands

Create a markdown file with your command:

echo "<command instructions>" > .claude/commands/my-command.md

Invoke your command:

/my-command

As you notice commands names are derived from the markdown file name.

Example: Fix Issue Command

Create the command:

echo "Fix issue $ARGUMENTS" > .claude/commands/fix-issue.md

Use it:

/fix-issue https://github.com/your-repo/issues/123

The $ARGUMENTS variable captures everything you type after the command name. There are many many possibilities exists depending on your project scope. Check this github repository https://github.com/hesreallyhim/awesome-claude-code#slash-commands for some custom slash commands inspiration.

Scripting with Claude Code

Claude Code can run non-interactively on the command line, accepting piped input and output. This makes it powerful for writing automation scripts. Use the -p flag to provide a prompt without entering the interactive REPL. Combine Claude Code with other Unix commands using pipes

Example 1: Analyze Build Logs

wget <build-log-url> | claude -p "Explain the root cause of this build error"

Example 2: Review Git Diff

git diff | claude -p "Review these changes for potential issues"

Example 3: Analyze Log Files

tail -n 100 app.log | claude -p "Identify any error patterns in this log"

Example 4: Process Command Output

npm audit | claude -p "Prioritize these security vulnerabilities by severity"

This Unix-style composability lets you:

Automate code reviews in CI/CD pipelines
Analyze logs as part of deployment scripts
Create custom development workflows
Integrate AI assistance into existing toolchains

Conclusion

Claude Code brings AI-powered development assistance directly into your terminal. It’s not about replacing your coding skills: it’s about amplifying your productivity by handling repetitive tasks, navigating complex codebases, and implementing well-defined features while you focus on architecture and business logic.

Begin with simple, low-risk tasks: documentation generation, test creation, or code exploration. As you build confidence and understand Claude Code’s strengths and limitations, gradually tackle more complex features. Remember that clear, context-rich prompts yield better results, and iteration is normal: treat interactions as conversations, not one-shot commands.

Ready to get started? Initialize Claude Code in one of your projects and try your first simple task. Your future self will thank you for the time saved on repetitive work. If you have any questions or suggestions, please let me know in the comments and I’m happy to help. Also you can connect with me on Linkedin: https://www.linkedin.com/in/anjith-paila-2074891a/