AI Capabilities

TatsuCode is an agentic coding assistant. Unlike simple chat interfaces, it can take autonomous actions to accomplish tasks — reading files, making edits, running commands, and more.

What "Agentic" Means

When you ask TatsuCode to "fix the bug in the login function," it doesn't just suggest code. It:

1. Reads the relevant files to understand the code
2. Analyzes the problem and identifies the fix
3. Proposes changes with a diff preview
4. Applies the changes (with your approval)
5. Verifies by running tests or linting

You give the goal; TatsuCode figures out the steps.

Core Capabilities

File Operations

TatsuCode can read, write, and edit files in your project:

Reading:

> What does src/auth/login.ts do?
> Show me the database configuration
> Read the package.json

TatsuCode reads text files, images (for visual analysis), PDFs, and Jupyter notebooks.

You can also drag files and folders directly into the input area (from inside or outside the project). If an item cannot be fully read, TatsuCode can still keep its path as context.

Writing:

> Create a new utility file for date formatting
> Add a README to this project

New files are created with your approval.

Editing:

> Add error handling to the fetchUser function
> Fix the typo on line 42 of config.ts
> Replace all console.log with logger.debug

TatsuCode uses intelligent diff-based editing:

• Finds the exact location to change
• Applies minimal modifications
• Preserves formatting and style
• Shows you the diff before applying

Office Documents (DOCX/XLSX/PPTX/CSV)

TatsuCode can work with Office documents directly using markdown-style workflows.

> Read this quarterly-report.docx and summarize key risks
> Update Q3-revenue.xlsx with the new totals
> Replace "Draft" with "Final" in the slide deck
> Create a new project-update.docx from this outline

You can use it for:

• Reading Word, Excel, PowerPoint, and CSV files into structured text
• Writing new .docx, .xlsx, .pptx files from markdown content
• Editing existing Office files in-place (targeted content updates)

Code Analysis

Find symbols and definitions:

> Where is the UserService class defined?
> Find all functions that handle authentication

Analyze dependencies:

> What imports does this file use?
> Which files depend on utils/helpers.ts?

Lint and check for errors:

> Check this project for TypeScript errors
> Are there any issues with the Python code?

TatsuCode integrates with:

• TypeScript/JavaScript (via Biome)
• Python (via Ruff)
• C# (via Roslyn)
• And many more languages

Terminal Commands

TatsuCode can run commands in your terminal:

> Run the tests
> Build the project
> Start the dev server
> Install the missing dependency

Commands require your approval before execution. You can:

• Allow once
• Allow for the session
• Always allow (for trusted commands)

Web Search & Research

Search for documentation and solutions:

> Search for React 19 migration guide
> What are the best practices for JWT authentication?

Fetch and analyze web pages:

> Read the OpenAI API documentation
> What does the Prisma docs say about transactions?

YouTube Video Analysis

TatsuCode supports multiple YouTube analysis modes depending on your goal.

> Get transcript only for this YouTube video
> Analyze this YouTube tutorial and extract the setup steps
> Do a deeper video analysis and summarize mistakes to avoid

Common modes:

• Transcript mode — text + metadata only (fast, low token usage)
• Direct video analysis — for vision-capable routes that can process video/audio
• Deeper isolated analysis — delegated analysis flow for longer/complex videos

Browser Automation

For web development, TatsuCode includes a private DevBrowser:

> Open your local app URL in the browser
> Click the login button
> Fill the email field with test@example.com
> Take a screenshot
> Check for console errors

The DevBrowser is completely isolated from your system browser — no shared cookies, credentials, or browsing history.

Screenshot Analysis

TatsuCode can capture and analyze screenshots:

> Take a screenshot of the browser
> Capture the current window

Combined with vision-capable modern models (Claude, GPT, Gemini families), this enables:

• Visual debugging of UI issues
• Comparing before/after designs
• Analyzing error dialogs
• Understanding mockups and diagrams

File History & Undo

All file edits during a session are tracked:

> Undo the last edit to main.py
> Revert config.json to its original state
> Show me the edit history for this session

You can:

• Revert to any previous state
• View all files edited this session
• Search through edit history
• Restore original content

Agent Skills & Reusable Workflows

TatsuCode supports reusable skill workflows for specialized tasks.

Common use cases:

• Deep debugging and architecture analysis
• Consistent release checklists
• Team-standard code review flow
• Repeatable migration playbooks

Use:

/skills

To learn when to use built-in skills like deep-think and skill-editor, see Agent Skills.

Multi-Step Workflows

TatsuCode excels at complex, multi-step tasks:

Bug Fixing

> I'm getting "undefined is not a function" in auth.js. 
  Find and fix the issue.

TatsuCode will:

1. Read the file and related code
2. Trace the error source
3. Identify the root cause
4. Propose and apply the fix
5. Optionally run tests to verify

Feature Development

> Add a password reset feature to the auth module

TatsuCode will:

1. Analyze existing auth code
2. Plan the implementation
3. Create necessary files
4. Integrate with existing code
5. Add tests if appropriate

Refactoring

> Refactor the UserController to use dependency injection

TatsuCode will:

1. Understand the current structure
2. Identify what needs to change
3. Make coordinated edits across files
4. Preserve existing functionality

Code Review

> Review the changes in src/components/ for security issues

TatsuCode will:

1. Read the relevant files
2. Analyze for common vulnerabilities
3. Report findings with explanations
4. Optionally fix issues

Limitations

What TatsuCode Can't Do

• Access your browser's cookies or credentials (DevBrowser is isolated)
• Edit system or Windows files that could damage the operating system
• Make destructive changes to your git repository without approval
• Run destructive terminal commands without approval (unless you've allowed them)

Note: TatsuCode includes guardrails to prevent harmful actions, but AI models can occasionally find unexpected workarounds. We recommend monitoring activity during sensitive operations and reviewing changes before approving them.

When to Guide It

TatsuCode works best when you:

• Be specific — "Fix the null check in getUserById" beats "fix the bug"
• Provide context — Mention the framework, conventions, or constraints
• Break down big tasks — Large requests may need multiple steps
• Review changes — Always check diffs before approving

Best Practices

Let TatsuCode Choose Tools

Instead of prescribing how:

# Less effective
> Read main.py, then edit line 42 to fix the bug

# More effective  
> Fix the authentication bug in main.py

Iterate Naturally

> Add input validation to the form
> Actually, also add client-side validation
> And show error messages below each field

Use Context from Files

Reference files with @:

> Looking at @auth.ts and @user.ts, how should I implement session management?

Monitor Long Sessions

For long conversations:

• Use /usage to check context consumption
• Use /compact to compress when needed
• Start /new sessions for unrelated work

Next Steps

• Tools Reference — Detailed tool documentation
• Agent Skills — Specialized reusable workflows
• DevBrowser — Browser automation details
• File History — Undo and versioning
• Commands — All slash commands