advanced_tools
Use when finding files by name, searching code content, locating patterns with regex, exploring codebase, or batch refactoring across multiple files. Conforms to docs/reference/skill-routing-value-standard.md.
Best use case
advanced_tools is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when finding files by name, searching code content, locating patterns with regex, exploring codebase, or batch refactoring across multiple files. Conforms to docs/reference/skill-routing-value-standard.md.
Teams using advanced_tools should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/advanced_tools/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How advanced_tools Compares
| Feature / Agent | advanced_tools | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when finding files by name, searching code content, locating patterns with regex, exploring codebase, or batch refactoring across multiple files. Conforms to docs/reference/skill-routing-value-standard.md.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Advanced Tools Skill (Batch Replace, Smart Search, Smart Find)
You have loaded the **Advanced Tools (Find & Search) Skill**.
## The Search Engine of Agentic OS
This skill is the **PRIMARY** gateway for locating anything in the project. It wraps high-performance Rust tools.
| Category | Tool | Implementation | Best For |
| ------------ | --------------- | --------------- | ----------------------------- |
| **Locator** | `smart_find` | **fd-find** | Finding FILES by name/path |
| **Searcher** | `smart_search` | **ripgrep** | Finding TEXT inside files |
| **Refactor** | `batch_replace` | **Rust/Python** | Multi-file search and replace |
## Available Tools
### smart_find: Fast File Location
**ALWAYS use this to find files.** Superior to `ls` or `list_directory` for discovery.
```python
def smart_find(
pattern: str = ".", # Regex or glob for filename
extension: str = None, # Filter: 'py', 'rs', 'md'
exclude: str = None, # Patterns to ignore
search_mode: str = "filename" # "filename" (fd) or "content" (rg -l)
) -> dict
```
### smart_search: Fast Code Search
**ALWAYS use this to find code content.** The gold standard for `grep`.
```python
def smart_search(
pattern: str, # Text or regex to find (REQUIRED)
file_globs: str = None, # Filter: "*.py *.ts"
case_sensitive: bool = True,
context_lines: int = 0
) -> dict
```
### batch_replace: Safe Refactoring
**RECOMMENDED for mass changes.** Always includes a dry-run preview.
```python
def batch_replace(
pattern: str, # Find this
replacement: str, # Replace with this
file_glob: str = "**/*",
dry_run: bool = True # Default is PREVIEW for safety
) -> dict
```
## Batch Replace Command (Primary Query Anchor)
`batch replace` is the canonical query phrase for this tool in documentation and routing.
Use `batch_replace` when you need deterministic multi-file replacement with dry-run safety.
## Linked Notes
- Related: [Code Tools Skill](../../../docs/reference/code-tools.md)
- Related: [Skill Routing Value Standard](../../../docs/reference/skill-routing-value-standard.md)
## Use Cases & Intention
- **"Find all python files"** -> `smart_find(extension="py")`
- **"Where is the Kernel defined?"** -> `smart_search(pattern="class Kernel")`
- **"Find files containing API_KEY"** -> `smart_find(pattern="API_KEY", search_mode="content")`
- **"Rename variable 'old_name' to 'new_name'"** -> `batch_replace(...)`
## Important Rules
1. **Discovery First**: If you don't know where a file is, use `smart_find`.
2. **Context Matters**: Use `smart_search` with `context_lines` to understand match surroundings.
3. **Respect Ignored**: All tools automatically respect `.gitignore`.
4. **Prefer Patterns**: Use specific regex patterns to reduce noise.Related Skills
advanced-workflows
Multi-tool orchestration patterns for complex Bluera Knowledge operations. Teaches progressive library exploration, adding libraries with job monitoring, handling large result sets, multi-store searches, and error recovery workflows.
Advanced Typescript Type Level
Master TypeScript type-level programming with conditional types, mapped types, template literals, and infer patterns. Use when writing advanced types, creating utility types, or solving complex type challenges.
advanced-typescript-patterns
Advanced TypeScript patterns for TMNL. Covers conditional types, mapped types, branded types, generic constraints, type inference, and utility type composition. Pure TypeScript patterns beyond Effect Schema.
advanced-types
Advanced TypeScript types including generics, conditionals, and mapped types
Advanced React Clean Integration
Integrate React with clean architecture without framework leakage using hooks as adapters and presenters. Use when connecting React to domain logic, designing hook-based DI, or isolating UI from business rules.
Advanced RE Analysis
Specialized reverse engineering analysis workflows for binary analysis, pattern recognition, and vulnerability assessment
Advanced Playwright E2E Framework
Enterprise-grade Playwright test automation framework using 8-layer architecture with Page Object Model, Module Pattern, custom fixtures, API testing layer, structured logging, data generators, multi-browser support, Docker, CI/CD pipelines, and custom HTML reporting.
Advanced Modular Library Design
Design modular libraries with clear package boundaries, feature-first organization, and clean API surfaces. Use when structuring monorepos, defining module boundaries, or designing library APIs.
advanced-memoization-strategies
Apply principled memoization techniques to reduce re-rendering without introducing correctness bugs.
advanced-git
Advanced Git - interactive rebase, cherry-pick, bisect, reflog, and power user operations
Advanced GetX Patterns
Advanced GetX features including Workers, GetxService, SmartManagement, GetConnect, GetSocket, bindings composition, and testing patterns
advanced-debugging
Advanced debugging skill for MyJKKN project. Specialized workflows for debugging Next.js 15, Supabase, React Query, TypeScript, and service layer issues. Includes automated analysis tools, common error patterns, and step-by-step troubleshooting guides for reducing debugging time. Use when investigating bugs, errors, performance issues, or unexpected behavior. (project)