feat: Add premium category cards to replace table view

- Horizontal card layout with emoji icons
- Soft-Tech color scheme (Oxford Blue, Peach Coral)
- Hover effects with arrow animation
- Responsive grid for all screen sizes

Author: devradarapp

_ai_tools/claude-code.md

@@ -1,45 +1,313 @@
 ---
-title: Claude Code
-slug: claude-code
-excerpt: "Autonomous AI coding agent by Anthropic with CLI-first workflow, 200K context window, and multi-file refactoring capabilities."
-description: Claude Code is an autonomous AI coding agent that operates through the CLI, capable of traversing file systems and orchestrating complex multi-file refactors.
-category: AI Tool
-tags: [ai, cli, agent, anthropic]
+title: "Claude Code Review: Agentic CLI with Claude 4.5 (2026)"
+description: "Claude Code analysis: Anthropic's CLI agent with Sonnet 4.5, Opus 4.5, MCP support, and Extended Thinking. Compare Claude Code vs Cursor, Copilot for terminal coding."
+category: ai-tools
+tags: [claude-code-ai-cli, claude-terminal-agent, claude-4-5-sonnet, agentic-engineering-cli, anthropic-coding-assistant]
+focus_keyword: "Claude Code AI CLI"
+meta_title: "Claude Code Review: Agentic CLI with Claude 4.5 (2026)"
+meta_description: "Claude Code analysis: Anthropic's CLI agent with Sonnet 4.5, Opus 4.5, MCP support, and Extended Thinking. Compare Claude Code vs Cursor, Copilot for terminal coding."
+last_updated: 2026-01-20
 version: "2.0.x"
-status: Stable
+status: stable
+license: Proprietary (Anthropic)
+official_url: https://claude.ai/code
+github: https://github.com/anthropics/claude-code
+quick_answer: "Claude Code is Anthropic's terminal-based AI agent that operates as an autonomous coding assistant through the command line interface. Unlike traditional autocomplete tools, it can execute shell commands, manage version control, and orchestrate complex multi-file refactors across your entire codebase."
+tagline: "The era of agentic engineering begins in the terminal"
+research_date: 2026-01-20
+related: [cursor, github-copilot, windsurf]
+capabilities: [["CLI Agent", true, "Terminal-based autonomous agent with full system access"], ["MCP", true, "Model Context Protocol for external integrations"], ["Extended Thinking", true, "Deep reasoning mode with internal monologue"], ["Plan Mode", true, "Architectural planning before execution"], ["Compaction", true, "Infinite session length via context summarization"]]
+best_for: ["Complex multi-file refactors", "DevOps automation", "Cross-framework development", "Enterprise integration workflows"]
+avoid_for: ["Simple single-file edits", "Teams requiring GUI-only workflow", "Users uncomfortable with CLI"]
+pricing: "Pro $20/month | Max $100-200/month | Team/Enterprise custom"
+search_intent: informational
 ---
 
+# Claude Code AI CLI: The Era of Agentic Engineering
+
 ## Quick Answer
 
-Claude Code excels at autonomous code refactoring and multi-file architectural changes. Use it for complex development tasks that require deep context awareness and the ability to execute shell commands. Consider alternatives if you require IDE-integrated autocomplete or have strict data governance requirements.
+**Claude Code** is Anthropic's command-line interface (CLI) AI agent that represents a fundamental shift from autocomplete-based coding assistants to autonomous agentic engineering. Unlike traditional tools embedded in IDEs, Claude Code operates directly in the terminal with full access to execute shell commands, traverse file systems, manage version control, and orchestrate complex multi-file architectural refactors. Powered by the **Claude 4.5 model family** (Sonnet, Opus, and Haiku), it supports **Model Context Protocol (MCP)** integrations, **Extended Thinking** for deep reasoning, and a sophisticated **compaction algorithm** that enables effectively infinite session lengths.
+
+## What is Claude Code?
+
+Claude Code is Anthropic's official CLI-based AI coding assistant, released as part of the Claude 4.5 model family rollout in late 2025. While traditional AI coding tools like GitHub Copilot or Cursor operate as IDE plugins with limited scope, Claude Code returns to the command line interface—a strategic architectural decision that grants the agent unmediated access to the operating system's toolchain.
 
-## Overview
+The tool functions as a "pseudo-user" in your terminal, capable of:
+- Reading and writing files across your entire project
+- Executing build commands and capturing error output in real-time
+- Managing Git operations (status, commits, branch management)
+- Running tests and iteratively fixing failures
+- Integrating with external systems via MCP
 
-Claude Code is an autonomous AI coding agent developed by Anthropic. Unlike traditional "copilot" tools that provide inline autocomplete, Claude Code operates as a terminal-based agent capable of traversing file systems, executing shell commands, managing version control, and orchestrating complex multi-file architectural refactors with minimal human intervention.
+This autonomous agentic approach enables workflows previously unattainable with passive autocomplete tools. For example, a platform engineering team can script migration tasks and dispatch Claude Code to process hundreds of microservices in parallel.
 
 ## Key Features
 
-- **CLI Paradigm:** Native terminal integration with full shell access
-- **Claude 4.5 Models:** Sonnet (generalist), Opus (architectural), Haiku (fast tasks)
-- **Extended Thinking:** Internal reasoning before output for complex debugging
-- **200K Token Context:** Massive context window with effective compaction
-- **MCP Integration:** Model Context Protocol for extensibility
+### CLI-Native Architecture
+
+Built on Node.js 18+, Claude Code ensures cross-platform compatibility across macOS, Linux, and Windows (via PowerShell or WSL). The `claude` command injects into the user's path and serves as the orchestration layer for:
+- Authentication with Anthropic's servers
+- Local context cache management
+- Headless mode for programmatic scripting
+- Interactive permission prompts for security
+
+The CLI paradigm fundamentally alters the developer-AI relationship. In GUI-based IDEs, AI is constrained by the editor's API surface. In the terminal, Claude Code interfaces directly with stdin/stdout/stderr, enabling real-time error capture and iterative fixes.
+
+### Claude 4.5 Model Family
+
+Claude Code leverages three distinct models, each optimized for different workflow dimensions:
+
+| Model | Role | Optimization |
+|-------|------|--------------|
+| **Claude Sonnet 4.5** | Generalist Workhorse | Default for most coding tasks—refactoring, bug fixing, feature implementation. Balances reasoning with low latency. |
+| **Claude Opus 4.5** | The Architect | Reserved for Plan Mode and complex architectural reasoning. Highest cognitive capacity for multi-system implications. |
+| **Claude Haiku 4.5** | The Tactician | High-speed, low-latency model for rapid sub-agent delegation—file scanning, documentation formatting, simple commands. |
+
+The model selection is automatic based on task complexity, though users can override via configuration. Opus 4.5 is particularly valuable for ambiguous requirements or systemic failures where deep reasoning is required.
+
+### Extended Thinking
+
+Introduced in late 2025, **Extended Thinking** decouples the model's internal reasoning from its output. When debugging complex scenarios, Claude Code allocates a token budget to "think"—using an internal scratchpad to hypothesize, test mental models, and discard incorrect assumptions before generating a final response.
+
+This internal monologue:
+- Reduces noise in user-facing context
+- Increases success rate of one-shot fixes
+- Is particularly effective for logical errors and multi-step debugging
+
+### Context Management & Compaction Algorithm
+
+With a 200,000-token context window (experimental support for 1M tokens), efficient context management is critical. Claude Code's **compaction algorithm** uses recursive summarization rather than simple truncation:
+
+- When context reaches ~95% capacity, background process triggers
+- Completed tasks, resolved errors, and intermediate steps are summarized
+- High-level decisions and architectural facts are preserved
+- Verbose thought processes and raw outputs of resolved steps are discarded
+
+This effectively enables **infinite session lengths**—developers can maintain a single session for days or weeks with the agent retaining "long-term memory" of project evolution.
+
+The `CLAUDE.md` file at project root acts as a persistent memory bank, storing architectural invariants, style guides, and project-specific commands injected at initialization.
+
+### Model Context Protocol (MCP) Support
+
+**MCP** is the interoperability standard that transforms Claude Code from a coding tool into a systems orchestrator. The protocol establishes a standardized connection between AI agents and external data sources.
+
+**Transport Types:**
+- **Stdio Transport**: For local development tools—MCP server runs as subprocess, communication via stdin/stdout. Highly secure for local file system and Git operations.
+- **HTTP/SSE Transport**: For cloud-native integrations—Server-Sent Events for downstream data, HTTP POST for upstream control. Enables centralized MCP servers for collaborative workflows.
+
+**Available MCP Integrations:**
+- **Core Infrastructure**: FileSystem (ACL-governed access), Git (semantic history search), Memory (persistent knowledge graph)
+- **Enterprise**: Linear, Jira (ticket requirements and PR linking), Sentry (production error analysis)
+- **Databases**: PostgreSQL, generic SQL servers (schema-aware query generation)
+
+### Plan Mode
+
+The `/plan` command engages Opus 4.5 to generate a comprehensive `plan.md` document detailing:
+- Architectural changes required
+- Dependency updates needed
+- Testing strategies
+- Step-by-step implementation approach
+
+Only after user approval does the agent switch to "Execute Mode," mimicking a senior engineer delegating to a junior developer. This separation prevents the "runaway agent" scenario and ensures alignment with project goals.
+
+## Claude Code vs Competitors
+
+### Claude Code vs Cursor
+
+| Dimension | Claude Code | Cursor |
+|-----------|-------------|--------|
+| **Interface** | CLI-native | VS Code fork (GUI) |
+| **Scope** | Full system access via terminal | IDE-bound with file/terminal tabs |
+| **Agency** | Autonomous with full shell execution | Agent Mode with constrained operations |
+| **Context** | 200k tokens with compaction | Limited by open files/selection |
+| **Best For** | Complex refactors, DevOps, scripting | Interactive editing, visual workflows |
+
+**Key Difference:** Cursor excels at interactive editing within the IDE, while Claude Code shines for autonomous workflows that span multiple files, require shell execution, or involve infrastructure management.
+
+### Claude Code vs GitHub Copilot
+
+| Dimension | Claude Code | GitHub Copilot |
+|-----------|-------------|----------------|
+| **Architecture** | CLI agent with full system access | IDE plugin with autocomplete focus |
+| **Models** | Claude 4.5 (Sonnet/Opus/Haiku) | GPT-4o Turbo |
+| **Agency** | Autonomous planning and execution | Suggestion-based, requires user acceptance |
+| **Integration** | MCP for external systems | GitHub ecosystem integration |
+| **Pricing** | $20-200/month + API credits | $10-20/month |
+
+**Key Difference:** Copilot remains a "copilot"—waiting for user invocation and limited to suggestions. Claude Code is an autonomous agent capable of planning and executing complex workflows with minimal intervention.
+
+### Claude Code vs Cline
+
+| Dimension | Claude Code | Cline |
+|-----------|-------------|-------|
+| **Platform** | Standalone CLI | VS Code extension |
+| **Models** | Claude 4.5 family | BYOK (Claude, GPT-4o, DeepSeek, local) |
+| **Workflow** | Plan + Execute modes | Plan & Act dual-phase |
+| **MCP Support** | First-party native | MCP host integration |
+
+**Key Difference:** Cline brings agentic capabilities within VS Code, while Claude Code offers a dedicated terminal experience with deeper model integration and first-party MCP support.
+
+### Claude Code vs Aider
+
+| Dimension | Claude Code | Aider |
+|-----------|-------------|-------|
+| **Architecture** | Node.js CLI | Python CLI |
+| **Models** | Claude 4.5 only | BYOK via LiteLLM (Claude, GPT-4o, DeepSeek, local) |
+| **Git Integration** | Via MCP tools | Git-native with auto-commit |
+| **Context** | 200k tokens with compaction | AST-based Repository Map |
+
+**Key Difference:** Aider is git-native with automatic commits after every change. Claude Code offers broader MCP ecosystem integration and superior reasoning via Opus 4.5 for complex tasks.
+
+## Technical Architecture
+
+### System Requirements
+
+- **Node.js**: Version 18 or higher
+- **Operating Systems**: macOS, Linux, Windows (via WSL or PowerShell)
+- **Authentication**: Anthropic API key or Claude account
+
+### Installation
+
+```bash
+# Via npm
+npm install -g @anthropic-ai/claude-code
+
+# Via official binary
+curl -fsSL https://install.anthropic.com | sh
+```
+
+### Security Model
+
+**Human-in-the-Loop**: By default, operations modifying the file system, executing shell commands, or sending data to MCP servers require explicit user confirmation.
+
+**Permission Controls**:
+- Interactive prompts for destructive operations
+- Allowlist/blocklist for sensitive directories (e.g., `.env`, `~/.ssh`)
+- `--dangerously-skip-permissions` flag for sandboxed environments only
+
+**Secret Detection**: Heuristic redaction of API keys and credentials from output logs.
+
+### Data Retention & Privacy
+
+| Plan Type | Training Usage | Retention | Compliance |
+|-----------|----------------|-----------|------------|
+| **Pro/Max** | Opt-out training (up to 5 years) | Standard | Consumer-grade |
+| **Team/Enterprise** | No training | 30-day or custom | SOC 2, HIPAA (BAA), GDPR |
+
+**Critical Note**: Only Team and Enterprise plans guarantee code is never used for model training.
+
+## Framework Compatibility
+
+### Frontend (Tier 1)
+
+| Framework | Support Level | Notes |
+|-----------|---------------|-------|
+| **React / Next.js** | Native | App Router migration, Server Actions, Hydration debugging |
+| **Astro** | Native | Islands architecture, Content Collections typing |
+| **SolidJS** | High | Signal-based reactivity, avoids React VDOM patterns |
+| **Qwik** | High | Resumability paradigm, `$` serialization boundaries |
+| **Svelte / SvelteKit** | High | Svelte 5 runes, file-based routing |
+
+### Backend (Tier 1)
+
+| Language/Framework | Support Level | Notes |
+|--------------------|---------------|-------|
+| **Python (FastAPI)** | Native | Pydantic models, `uv` package manager integration |
+| **Python (Django)** | Native | MVT architecture, migration generation |
+| **Rust** | High | Idiomatic ownership/borrowing, cargo management |
+| **Go** | High | `gofmt` standards, table-driven tests |
+
+### Databases (Tier 1)
+
+| Database | Integration Type | Capabilities |
+|----------|------------------|--------------|
+| **Supabase** | Official MCP | Schema inspection, RLS policies, Edge Functions |
+| **Cloudflare D1** | MCP/CLI | Migration generation, wrangler bindings |
+| **Turso / Neon** | Generic SQL MCP | Via drizzle-setup, ORM-aware queries |
+
+### Hosting (Tier 1)
+
+| Platform | Integration | Capabilities |
+|----------|-------------|--------------|
+| **Cloudflare** | Native CLI | wrangler.toml, Workers/Pages deployment |
+| **Vercel** | CLI | vercel.json, Edge Middleware, preview deployments |
+| **Netlify** | MCP/CLI | netlify.toml, Build Plugins, rollback automation |
+| **Railway / Fly.io** | CLI | nixpacks/Dockerfile generation, log analysis |
 
 ## Best For
 
-- Complex architectural refactors spanning multiple files
-- Automated debugging with iterative self-healing
-- CI/CD pipeline integration via headless mode
-- Teams comfortable with terminal-based workflows
+- **Complex multi-file refactors**: Architectural changes spanning dozens of files
+- **DevOps automation**: CI/CD pipeline management, infrastructure as code
+- **Cross-framework development**: Teams working across multiple technology stacks
+- **Enterprise integration**: Jira, Linear, Sentry workflows via MCP
+- **Test-driven development**: Autonomous TDD loops with test generation and iteration
 
 ## Avoid For
 
-- Developers who prefer GUI-based IDE interactions
-- Organizations requiring zero data retention (requires Enterprise plan)
-- Quick autocomplete-style suggestions (use Copilot instead)
+- **Simple single-file edits**: Overkill for quick syntax fixes
+- **GUI-only teams**: Developers uncomfortable with terminal workflows
+- **Real-time collaborative editing**: Cursor/Windsurf better suited for pair programming
+- **Strict budget constraints**: Active usage can consume $6-12/day in API credits
 
 ## Pricing
 
-- **Pro:** $20/month (~40-80 hours/week)
-- **Max:** $100-200/month (unlocks Opus 4.5)
-- **API:** Pay-as-you-go credits available
+| Plan | Monthly Cost | Sonnet 4.5 | Opus 4.5 | Use Case |
+|------|--------------|------------|----------|----------|
+| **Pro** | $20 | ~40-80 hours/week | No | Individual developers, supplementary usage |
+| **Max ($100)** | $100 | ~5x Pro limits | Yes | Power users, frequent architectural work |
+| **Max ($200)** | $200 | ~20x Pro limits | Yes | Professional teams, heavy automation |
+| **Team/Enterprise** | Custom | Unlimited | Yes | Organizations requiring compliance guarantees |
+
+**API Credit Pricing** (for overages):
+- Sonnet 4.5: $3 per million input / $15 per million output
+- Opus 4.5: $5 per million input / $25 per million output
+
+## FAQ
+
+### Is Claude Code free?
+
+Claude Code is not free. The Pro plan costs $20/month with usage limits. The Max plan ($100-200/month) is required for access to Opus 4.5 and higher rate limits. API credits are available for pay-as-you-go usage beyond subscription limits.
+
+### How does Claude Code differ from ChatGPT or Claude.ai?
+
+Claude Code is a CLI agent with autonomous capabilities to execute commands, modify files, and manage your development environment. ChatGPT and Claude.ai are chat interfaces that generate code but cannot directly interact with your system or execute workflows.
+
+### What is the Claude Code CLI tutorial?
+
+To get started with Claude Code:
+1. Install via `npm install -g @anthropic-ai/claude-code`
+2. Run `claude` to launch the agent
+3. Use `/plan` for architectural planning
+4. Use natural language to describe tasks
+5. Approve operations via interactive prompts
+
+### Can Claude Code configure MCP automatically?
+
+MCP servers must be configured manually via the `/mcp` command suite. Claude Code can assist with configuration once you specify the server details, but automatic discovery is not supported for security reasons.
+
+### How does Claude 4.5 Sonnet compare to Opus for coding?
+
+Sonnet 4.5 is optimized for interactive coding tasks with low latency. Opus 4.5 provides deeper reasoning for complex architectural challenges but has higher latency and cost. Use Sonnet for routine development; reserve Opus for planning mode and ambiguous problems.
+
+### What is the best terminal AI assistant 2026?
+
+The "best" depends on workflow:
+- **Claude Code**: Best for autonomous workflows and enterprise integration
+- **Cursor**: Best for interactive editing within VS Code
+- **Aider**: Best for git-native workflows with BYOK flexibility
+- **Cline**: Best for VS Code users wanting agentic capabilities
+
+### How do I set Claude Code pricing limits?
+
+Pricing is controlled via subscription tier selection and API credit budgets. Enterprise customers can negotiate custom limits. Monitor usage via community tools like `ccusage` which parses local `.jsonl` log files.
+
+### Does Claude Code support local models?
+
+Native Claude Code only supports Anthropic's hosted models. However, community proxy tools like `claude-code-proxy` enable BYOK workflows and can route requests to local models via LiteLLM, though agentic tuning may be degraded.
+
+---
+
+**Research Version**: 2.0.x (Late 2025)
+**Analysis Date**: January 20, 2026
+**Next Review**: March 2026