Stop Wasting Claude's Potential! Unlock Vibe Coding with feiskyer/claude-code-settings

Your AI assistant is only as good as the scaffolding you build around it.

If you're still using Claude Code out-of-the-box, you're leaving insane productivity gains on the table. Every day, developers waste hours on repetitive tasks—switching between tools, manually configuring API proxies, stitching together research workflows, and begging Claude to remember context from three sessions ago. The pain is real. The friction is exhausting. And the worst part? Most developers don't even realize there's a better way.

Enter feiskyer/claude-code-settings—a meticulously curated collection of Claude Code settings, skills, and sub-agents that transforms your terminal from a simple chat interface into a vibe coding command center. This isn't just a dotfiles repo. It's a force multiplier for developers who want to automate the boring, amplify the creative, and ship faster than ever before. Whether you're orchestrating multi-agent research, generating images mid-coding session, or seamlessly switching between Claude, GPT-5, and DeepSeek models without breaking flow—this setup has you covered.

Ready to stop configuring and start creating? Let's dive deep into why top developers are quietly adopting this configuration as their secret weapon.

What is feiskyer/claude-code-settings?

feiskyer/claude-code-settings is an open-source configuration framework created by Pengfei Ni (@feiskyer), a seasoned engineer with deep expertise in cloud-native technologies and developer tooling. Hosted at https://github.com/feiskyer/claude-code-settings, this repository represents one of the most comprehensive and battle-tested Claude Code customization projects in the ecosystem.

The project emerged from a simple but profound observation: Claude Code's default capabilities, while impressive, are just the starting line. Anthropic designed the platform to be extensible through skills, plugins, and sub-agents—but building these from scratch is time-consuming and error-prone. Feiskyer's collection bridges this gap by providing production-ready, drop-in enhancements that cover the entire development lifecycle.

What makes this repository trending now? Three converging forces:

1. The rise of "vibe coding"—a developer movement emphasizing flow state, minimal context switching, and AI-assisted creativity over mechanical configuration.
2. Claude Code 2.0's expanded plugin ecosystem, which finally made third-party skill distribution practical.
3. Multi-model fatigue—developers are exhausted from managing separate interfaces for Claude, GPT-5, DeepSeek, and Qwen. This repo unifies them under one roof.

The repository's philosophy is modular opt-in power. You don't need to adopt everything. Install a single skill for YouTube transcript extraction, or go all-in with the full autonomous agent stack. The choice is yours—but the ceiling is sky-high.

Key Features That Separate Amateurs from Pros

Let's dissect what makes this configuration genuinely transformative for daily development work.

Multi-Model Gateway Architecture

The default setup leverages LiteLLM Proxy Server as a universal LLM gateway, but that's just the beginning. Pre-configured settings exist for GitHub Copilot, DeepSeek v3.1, Qwen3-Coder-Plus, SiliconFlow, Google Vertex AI, Azure AI Foundry, MiniMax, and OpenRouter. This isn't just convenience—it's strategic model arbitrage. Use Claude Opus for architecture, GPT-5 for rapid prototyping, DeepSeek for cost-effective batch processing, all without changing your workflow.

Specialized Skill Ecosystem (15+ Skills)

From codex-skill (seamless handoff to OpenAI Codex CLI) to deep-research (multi-agent research orchestration), each skill solves a specific, high-friction problem. The nanobanana-skill and gpt-image-skill bring image generation directly into your coding session—no more tab-switching to Midjourney or DALL-E.

Autonomous Execution Patterns

The autonomous-skill implements a dual-agent pattern with Initializer and Executor roles, complete with session persistence across interruptions. This isn't simple automation—it's resilient, long-horizon task execution that survives crashes, reboots, and context window limitations.

Constitution-Based Development

The spec-kit-skill integrates GitHub's Spec-Kit methodology, enforcing a 7-phase workflow from constitutional principles through implementation. For teams struggling with specification drift, this is structural salvation.

Intelligent Reflection & Learning

The reflection skill doesn't just analyze sessions—it improves future sessions by automatically updating your CLAUDE.md instructions based on observed patterns and preferences. Your AI assistant literally gets smarter about you over time.

Pre-Configured Provider Settings

Ten different settings.json configurations eliminate the API endpoint juggling that plagues multi-model developers. Copy, tweak credentials, deploy.

Use Cases: Where This Configuration Absolutely Shines

1. The Full-Stack Feature Sprint

You're building a new authentication system. With kiro-skill, you define requirements in EARS format. spec-kit-skill generates dependency-ordered tasks. codex-skill hands implementation details to GPT-5.1 when Claude's context saturates. The autonomous-skill continues overnight. You review the final_report.md over coffee. Shipped while you slept.

2. Technical Research & Competitive Analysis

Need to analyze the AI agent framework landscape? Trigger deep-research with a Chinese query like "深度调研一下 AI Agent 框架的现状". The system decomposes this into parallel sub-objectives, spawns claude -p sub-processes, aggregates findings, and delivers a chaptered, source-verified report in .research/<name>/final_report.md. No more copy-pasting from 40 browser tabs.

3. Content Creation & Documentation

The youtube-transcribe-skill extracts subtitles from technical talks. translate converts English/Japanese articles to natural Chinese while preserving technical terminology. eureka captures your breakthrough moments into searchable breakthroughs/ archives. Knowledge management becomes automatic, not aspirational.

4. Visual-First Development

Need a mockup for your new dashboard? Invoke nanobanana-skill with Gemini API for 4K image generation, or gpt-image-skill for transparent PNG assets with OpenAI's latest models. Design iterations happen in your terminal, not Figma's loading screen.

Step-by-Step Installation & Setup Guide

Method 1: Claude Code Plugin (Recommended)

The fastest path to productivity. Execute these commands in your Claude Code session:

# Register the marketplace source
/plugin marketplace add feiskyer/claude-code-settings

# Install the complete plugin bundle
/plugin install claude-code-settings

# Or cherry-pick individual skills
/plugin install codex-skill               # OpenAI Codex integration
/plugin install autonomous-skill          # Long-running task automation
/plugin install nanobanana-skill          # Gemini image generation
/plugin install kiro-skill                # Feature development workflow
/plugin install spec-kit-skill            # Constitution-based specs
/plugin install youtube-transcribe-skill  # YouTube subtitle extraction

Critical note: ~/.claude/settings.json requires manual configuration even with plugin installation. Don't skip this step.

Method 2: npx Skills (Tool-Agnostic)

For developers using multiple AI coding tools beyond Claude Code:

# Discover available skills
npx -y skills add -l feiskyer/claude-code-settings

# Bulk install everything
npx -y skills add --all feiskyer/claude-code-settings

# Interactive selection
npx -y skills add feiskyer/claude-code-settings

Method 3: Manual Setup (Maximum Control)

For power users who want complete transparency:

# Preserve your existing configuration
mv ~/.claude ~/.claude.bak

# Clone the complete repository
git clone https://github.com/feiskyer/claude-code-settings.git ~/.claude

# Install the LLM gateway dependency
pip install -U 'litellm[proxy]'

# Launch the proxy server (listens on :4000)
litellm -c ~/.claude/guidances/litellm_config.yaml

You'll see authentication instructions:

...
Please visit https://github.com/login/device and enter code XXXX-XXXX to authenticate.
...

Complete GitHub Copilot authentication, then optionally daemonize:

# Background execution with tmux
tmux new-session -d -s copilot 'litellm -c ~/.claude/guidances/litellm_config.yaml'

Post-Installation: Model Verification

Ensure these models are accessible in your account, or substitute equivalents:

• ANTHROPIC_DEFAULT_SONNET_MODEL: claude-sonnet-4.6
• ANTHROPIC_DEFAULT_OPUS_MODEL: claude-opus-4.6
• ANTHROPIC_DEFAULT_HAIKU_MODEL: gpt-5-mini

REAL Code Examples from the Repository

Let's examine actual implementations from the repository, with detailed explanations of how they work in practice.

Example 1: Autonomous Skill Task Initialization

The autonomous-skill demonstrates sophisticated session management. Here's how it structures a long-running task:

# User initiates a complex task
You: "Please use autonomous skill to build a REST API for a todo app"

# Claude's response pattern:
Claude: [Creates .autonomous/build-rest-api-todo/, initializes task list, starts execution]

Behind this simple interaction lies a dual-agent architecture:

.autonomous/build-rest-api-todo/
├── task_list.md      # Master task inventory created by Initializer
├── progress.md       # Execution state updated by Executor
├── logs/             # Per-session execution records
└── artifacts/        # Deliverables and checkpoints

The Initializer agent decomposes your request into atomic, verifiable tasks. The Executor agent processes these sequentially, persisting state after each completion. If your session terminates—network hiccup, laptop sleep, intentional break—the next invocation resumes from progress.md rather than starting fresh. This is fault-tolerant automation that respects real-world development conditions.

Example 2: Deep Research Multi-Agent Orchestration

The deep-research skill showcases parallel sub-process execution with structured output. Trigger it with natural language:

You: "深度调研一下 AI Agent 框架的现状"
Claude: [Initiates reconnaissance, proposes sub-objectives, waits for confirmation, then orchestrates parallel research]

The resulting directory structure demonstrates enterprise-grade research organization:

.research/ai-agent-frameworks-2025/
├── prompts/           # Version-controlled sub-task definitions
├── child_outputs/     # Raw outputs from each claude -p subprocess
├── logs/              # Dispatcher and per-task execution traces
├── raw/               # Cached web data, API responses, document extracts
└── final_report.md    # Iteratively polished, chaptered deliverable

The skills-first resolution strategy is particularly clever: it prioritizes installed skills, falls back to MCP tools (Firecrawl → Exa), then uses generic WebFetch/WebSearch. This cascading capability detection ensures optimal tool selection without manual intervention.

Example 3: Spec-Kit Constitution Initialization

The spec-kit-skill enforces rigorous specification discipline through CLI integration:

# Install the specification framework
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# Initialize with AI-assisted defaults
specify init . --ai claude

This creates a .specify/ directory that drives the 7-phase workflow:

You: "Let's create a constitution for this project"
Claude: [Automatically uses spec-kit-skill, detects CLI, guides through phases]

The phases progress from Constitution (governing principles) through Specify, Clarify (capped at 5 questions to prevent analysis paralysis), Plan, Tasks, Analyze (read-only validation), to Implement. The max 5 questions constraint in Clarify phase is a deliberate anti-bikeshedding mechanism—it forces decisive specification rather than infinite refinement.

Example 4: Eureka Breakthrough Documentation

The eureka skill demonstrates structured knowledge capture with minimal friction:

You: "/eureka Reduced API response time from 2s to 100ms by implementing request batching"
Claude: [Creates breakthroughs/2025-01-15-api-request-batching.md, updates INDEX.md]

Each breakthrough file follows a standardized template:

# API Request Batching Optimization

## Problem
Sequential API calls causing 2s+ response times under load.

## Insight
Requests share identical authentication and base parameters; 
batching reduces round-trips by 94%.

## Implementation
- Implemented Promise.all() with 50-request chunks
- Added circuit breaker for partial failures
- Maintained backward compatibility via adapter pattern

## Impact
- Response time: 2000ms → 100ms (95% reduction)
- Throughput: 120 → 2,400 requests/minute
- Infrastructure cost: -60% (fewer compute instances)

## References
- [Commit: a3f7d2e](link)
- [Load test results](link)

The automatic INDEX.md maintenance creates a searchable organizational memory that outlasts individual developer tenure.

Example 5: Plugin Update Automation

The maintenance script exemplifies operational hygiene:

# One-command ecosystem synchronization
bash ~/.claude/scripts/update-cc-plugins.sh

This script iterates through all registered marketplaces, updates plugin manifests, and refreshes skill definitions. For teams with multiple Claude Code installations, this prevents configuration drift and ensures security patches propagate automatically.

Advanced Usage & Best Practices

Model Provider Fallback Strategy

Configure multiple settings.json files and symlink based on project requirements. For open-source work, use GitHub Copilot (free tier). For proprietary code, switch to Azure AI Foundry with enterprise compliance. The contextual provider selection optimizes both cost and security.

Skill Composition Patterns

Chain skills for compound effects: youtube-transcribe-skill → translate → deep-research transforms foreign-language technical talks into structured competitive analysis. The output of each skill becomes the input context for the next.

Autonomous Session Hygiene

Regularly archive .autonomous/ directories to cold storage. The task_list.md and progress.md files contain valuable process documentation that improves future estimations and reveals systematic bottlenecks.

CLAUDE.md Evolution

Run /reflection deep after major project phases. The comprehensive analysis mode examines problems solved, patterns identified, user preferences, system understanding gaps, and knowledge deficiencies. This produces iteratively improving instructions that personalize Claude's behavior to your cognitive style.

MCP Server Bridging

Since Anthropic's WebSearch tool requires official API access, proactively configure Tavily MCP, Brave MCP, or Firecrawl MCP when using third-party providers. The deep-research skill's fallback logic handles this gracefully, but explicit configuration eliminates latency.

Comparison with Alternatives

The verdict? Default Claude Code is a sports car with the parking brake on. Custom dotfiles are hot-rods—fast but fragile. Other skill collections are partial solutions. This repository is the professionally engineered tuning kit that maximizes performance without sacrificing reliability.

FAQ: Developer Concerns Addressed

Q: Is this officially supported by Anthropic?

A: No—this is community-created. However, it uses official APIs and documented extension points. The skills conform to Anthropic's published skill specification, and the sub-agents follow their sub-agent patterns. Think of it as a curated distribution rather than a hack.

Q: Will this break with Claude Code updates?

A: The repository is actively maintained with version-aware compatibility. The update-cc-plugins.sh script propagates changes. Critical skills use stable API surfaces rather than experimental features. Subscribe to repository releases for breaking change notifications.

Q: How do I handle API key security across multiple providers?

A: Use environment-specific .env files (~/.nanobanana.env, ~/.gpt-image.env) rather than shell exports. For team deployments, integrate with your existing secret manager (1Password, HashiCorp Vault) and inject at runtime.

Q: Can I use this with Claude Code 2.0+ VSCode extension?

A: Yes, but requires manual environment variable configuration in VSCode's settings.json. The repository's FAQ section provides the exact JSON structure needed for ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, and model aliases.

Q: What's the performance overhead of running LiteLLM proxy?

A: Negligible for local development. LiteLLM adds <5ms latency for request routing. The proxy enables model fallback (if Claude is rate-limited, auto-route to DeepSeek) and usage analytics that justify any minimal overhead.

Q: How do I contribute new skills or report issues?

A: The repository welcomes contributions via GitHub Issues and Pull Requests. Follow the existing skill structure with proper frontmatter, documentation, and requirements.txt for Python dependencies. The skill-creator skill itself can generate scaffolded new skills.

Q: Is "vibe coding" just marketing, or genuinely different?

A: Genuinely different. Traditional coding is tool-centric—you adapt to IDE constraints. Vibe coding is intent-centric—the toolchain adapts to your mental model. This configuration eliminates the friction points (context switching, configuration archaeology, repetitive setup) that break creative flow.

Conclusion: Your Terminal, Supercharged

feiskyer/claude-code-settings isn't merely a convenience—it's a fundamental reimagining of how developers interact with AI assistance. By unifying multi-model access, embedding autonomous execution patterns, and institutionalizing knowledge capture, it transforms Claude Code from a chat interface into a collaborative engineering partner.

The repository's modular architecture respects that no two developers work identically. Install everything, or install one skill. But install something—because every day you spend context-switching between tools is a day you're not building what matters.

My assessment? This is the most complete Claude Code enhancement project available today. The combination of practical automation (autonomous-skill), rigorous methodology (spec-kit-skill), and playful creativity (nanobanana-skill) reflects a holistic understanding of real development workflows that official tools haven't yet matched.

Stop configuring. Start vibe coding.

👉 Get feiskyer/claude-code-settings on GitHub — Star the repo, fork for your team, and join the growing community of developers who've stopped fighting their tools and started flowing with them.

Have you tried vibe coding with enhanced Claude Code setups? Share your experience in the comments—what skill saved you the most time?