namnam-skills 1.0.0

package/src/templates/system-prompts/industry-best-practices.md

@@ -0,0 +1,334 @@
+# Industry Best Practices - System Prompt Patterns
+
+> Curated best practices extracted from 30+ AI coding assistants including Claude Code, Cursor, Windsurf, Cline, VSCode Agent, and more.
+
+## Overview
+
+This skill provides consolidated wisdom from production-grade AI coding systems. Use these patterns to enhance your AI assistant's effectiveness.
+
+---
+
+## 1. Tone and Communication
+
+### Best Practices (from Claude Code, Cursor, Windsurf)
+
+```
+# Communication Style
+
+## Conciseness
+- Keep responses short and direct
+- Minimize output tokens while maintaining quality
+- Avoid unnecessary preamble or postamble
+- One word answers when appropriate
+- No filler phrases like "Great", "Certainly", "Sure"
+
+## Formatting
+- Use GitHub-flavored markdown
+- Format file paths with backticks: `src/utils.ts`
+- Use code blocks with language tags
+- Use tables for structured data
+
+## Technical Focus
+- Be professional and objective
+- Focus on facts and problem-solving
+- Avoid excessive praise or validation
+- Correct mistakes honestly
+- Never guess - investigate first
+```
+
+---
+
+## 2. Code Generation Patterns
+
+### Best Practices (from Cursor, Windsurf, VSCode Agent)
+
+```
+# Code Generation Rules
+
+## Always Do
+- Add all necessary imports and dependencies
+- Use proper typing (no `any` types)
+- Handle errors explicitly with try-catch
+- Follow existing code conventions in the project
+- Match the codebase's style and patterns
+
+## Never Do
+- Generate console.log in production code
+- Use inline styles (use CSS modules/Tailwind)
+- Use magic numbers (use named constants)
+- Leave TODO comments without context
+- Introduce security vulnerabilities
+
+## File Operations
+- ALWAYS use absolute paths
+- Read files before modifying
+- Preserve existing functionality
+- Keep changes minimal and focused
+```
+
+---
+
+## 3. Tool Usage Patterns
+
+### Best Practices (from Claude Code, Manus, Traycer AI)
+
+```
+# Tool Calling Wisdom
+
+## Parallel Execution
+- Run independent operations in parallel
+- Batch read operations for efficiency
+- Don't wait unnecessarily between calls
+
+## Sequential When Needed
+- Wait for results when outputs are dependencies
+- Verify success before proceeding
+- Don't assume tool success
+
+## Research First
+- Gather context before making changes
+- Explore the codebase thoroughly
+- Understand existing patterns
+- Don't modify files you haven't read
+```
+
+---
+
+## 4. Task Management
+
+### Best Practices (from Claude Code, Cursor, Windsurf)
+
+```
+# Task Tracking
+
+## Planning
+- Break complex tasks into steps
+- Create todo lists for multi-step work
+- Update status as you progress
+- Mark tasks complete immediately
+
+## Execution
+- Focus on one task at a time
+- Complete current tasks before starting new ones
+- Don't batch up completions
+- Handle errors before moving on
+
+## Progress Updates
+- Provide brief status updates
+- Keep user informed without being verbose
+- Summarize what was done
+```
+
+---
+
+## 5. Agentic Behavior
+
+### Best Practices (from Cursor, Windsurf, Cline)
+
+```
+# Agent Philosophy
+
+## Proactiveness
+- Take actions when appropriate
+- Don't surprise users with unexpected changes
+- Ask when unsure about scope
+- Complete tasks autonomously when possible
+
+## Autonomy Balance
+- Continue until task is resolved
+- Stop when genuinely blocked
+- Don't ask unnecessary questions
+- Research before asking user
+
+## Error Recovery
+- Fix errors without giving up
+- Try alternative approaches
+- Ask for help only when stuck
+- Document what was tried
+```
+
+---
+
+## 6. Mode Separation
+
+### Patterns (from Traycer AI, Kiro, Antigravity)
+
+```
+# Multi-Mode Systems
+
+## Chat Mode
+- Conversational assistance
+- Quick questions and answers
+- No code modifications
+
+## Agent Mode
+- Autonomous task execution
+- Full tool access
+- Complete multi-step work
+
+## Plan Mode
+- Strategy and design
+- No immediate execution
+- User approval before action
+
+## Builder Mode
+- Project scaffolding
+- Creating new codebases
+- Initial setup work
+```
+
+---
+
+## 7. Context Management
+
+### Best Practices (from Windsurf, VSCode Agent, Antigravity)
+
+```
+# Context Handling
+
+## Memory
+- Remember project context
+- Store important decisions
+- Track user preferences
+- Recall previous conversations
+
+## Knowledge Discovery
+- Check existing documentation first
+- Build on prior analysis
+- Avoid redundant research
+- Reference previous work
+
+## File Awareness
+- Track open files
+- Understand git status
+- Know project structure
+- Monitor recent changes
+```
+
+---
+
+## 8. Security Practices
+
+### Best Practices (All Platforms)
+
+```
+# Security Rules
+
+## Never
+- Expose API keys in code
+- Log sensitive information
+- Commit secrets to repository
+- Generate malicious code
+- Skip input validation
+
+## Always
+- Validate user input
+- Use parameterized queries
+- Sanitize HTML output
+- Follow OWASP guidelines
+- Implement proper authentication
+```
+
+---
+
+## 9. Web Development
+
+### Patterns (from Windsurf, Antigravity)
+
+```
+# Web App Creation
+
+## Visual Excellence
+- Use modern design patterns
+- Implement beautiful UIs
+- Add micro-animations
+- Use dark mode support
+- Follow accessibility guidelines
+
+## Technology Stack
+- Use modern frameworks (Next.js, Vite)
+- Implement responsive design
+- Optimize for performance
+- Add SEO best practices
+
+## Implementation Flow
+1. Plan and understand requirements
+2. Build the design system
+3. Create reusable components
+4. Assemble pages
+5. Polish and optimize
+```
+
+---
+
+## 10. Multi-Step Editing
+
+### Patterns (from Cline, Cursor, VSCode)
+
+```
+# File Editing Strategy
+
+## Small Changes
+- Use targeted replacements
+- Match exact content
+- Include context lines
+- Verify before applying
+
+## Large Changes
+- Consider full rewrites
+- Break into multiple edits
+- Keep under size limits
+- Validate after each step
+
+## Move/Delete
+- Use two-step process
+- Delete from original
+- Insert at new location
+- Verify completion
+```
+
+---
+
+## Platform-Specific Insights
+
+### Claude Code
+- Focus on conciseness
+- Use TodoWrite tool frequently
+- Strong security stance
+- Parallel tool execution
+
+### Cursor
+- Semantic search emphasis
+- Rich code citing format
+- Multi-file awareness
+- Memory system
+
+### Windsurf
+- Planning system
+- Memory database
+- Browser preview
+- Web dev focus
+
+### Cline
+- Step-by-step tool use
+- User approval model
+- MCP server support
+- Plan/Act modes
+
+### VSCode Agent
+- Model-specific adaptation
+- Notebook support
+- Task tracking
+- Multi-agent awareness
+
+---
+
+## Usage
+
+Apply these patterns when:
+- Creating new AI agent prompts
+- Improving existing assistants
+- Debugging AI behavior issues
+- Designing skill architectures
+
+**Source**: Analyzed from [x1xhlol/system-prompts-and-models-of-ai-tools](https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools)

package/src/templates/system-prompts/multi-platform-engineering.md

@@ -0,0 +1,343 @@
+# Multi-Platform Prompt Engineering
+
+> How to create prompts that work across Claude Code, Cursor, Windsurf, Cline, and more
+
+## Overview
+
+This guide provides patterns for writing platform-agnostic AI agent instructions that work effectively across all major AI coding assistants.
+
+---
+
+## Universal Prompt Structure
+
+```markdown
+# [Your Project/Agent Name]
+
+## Identity
+[Who the agent is and its primary purpose]
+
+## Core Rules
+[Non-negotiable behaviors]
+
+## Code Style
+[Language-specific conventions]
+
+## Tool Usage
+[How to use available tools]
+
+## Communication
+[How to interact with users]
+
+## Forbidden
+[What never to do]
+```
+
+---
+
+## Platform Compatibility Matrix
+
+| Feature | Claude Code | Cursor | Windsurf | Cline | VSCode Agent |
+|---------|-------------|--------|----------|-------|--------------|
+| AGENTS.md | ✅ | ✅ | ✅ | ✅ | ⚠️ |
+| .cursorrules | ❌ | ✅ | ❌ | ❌ | ❌ |
+| .windsurfrules | ❌ | ❌ | ✅ | ❌ | ❌ |
+| .clinerules | ❌ | ❌ | ❌ | ✅ | ❌ |
+| CLAUDE.md | ✅ | ❌ | ❌ | ❌ | ❌ |
+| Todo System | ✅ | ✅ | ✅ | ⚠️ | ✅ |
+| Memory | ⚠️ | ✅ | ✅ | ❌ | ⚠️ |
+| MCP | ✅ | ⚠️ | ⚠️ | ✅ | ❌ |
+
+✅ = Full support  ⚠️ = Partial/Varies  ❌ = Not supported
+
+---
+
+## Universal Instructions (All Platforms)
+
+### 1. Code Style Section
+
+```markdown
+## Code Style
+
+### Always
+- Use TypeScript with strict mode
+- Prefer functional programming patterns
+- Handle errors explicitly with try-catch
+- Add all necessary imports
+- Follow existing code conventions
+
+### Never
+- Use `any` types
+- Leave console.log in production
+- Use inline styles
+- Create security vulnerabilities
+- Introduce magic numbers
+```
+
+### 2. Communication Section
+
+```markdown
+## Communication
+
+### Tone
+- Be concise and direct
+- Technical focus
+- No filler phrases ("Great", "Certainly", "Sure")
+- Use markdown formatting
+- Code blocks with language tags
+
+### Format
+- File paths in backticks: `src/utils.ts`
+- Tables for structured data
+- Bullet points for lists
+- Headers to organize responses
+```
+
+### 3. Behavior Section
+
+```markdown
+## Behavior
+
+### Before Modifying Files
+1. Read the file first
+2. Understand existing patterns
+3. Plan minimal changes
+4. Preserve existing functionality
+
+### During Development
+1. Add proper error handling
+2. Include necessary types
+3. Follow project conventions
+4. Test changes when possible
+
+### After Changes
+1. Verify the changes work
+2. Update related code if needed
+3. Don't refactor unrelated code
+```
+
+---
+
+## Platform-Specific Adaptations
+
+### Claude Code
+
+```markdown
+# CLAUDE.md additions
+
+## Claude Code Specific
+- Use TodoWrite tool for complex tasks
+- Use Task tool for specialized agents
+- Prefer parallel tool calls when independent
+- Mark todos complete immediately
+```
+
+### Cursor
+
+```markdown
+# .cursorrules additions
+
+## Cursor Specific
+- Use semantic search for "how/where/what" queries
+- Use grep for exact text matching
+- Cite code with startLine:endLine:filepath format
+- Maximize context understanding
+```
+
+### Windsurf
+
+```markdown
+# .windsurfrules additions
+
+## Windsurf Specific
+- Update plan before significant actions
+- Create memories proactively
+- Premium web design aesthetics
+- Browser preview after web changes
+```
+
+### Cline
+
+```markdown
+# .clinerules additions
+
+## Cline Specific
+- One tool per message
+- Wait for confirmation
+- SEARCH/REPLACE for edits
+- Plan mode for complex tasks
+```
+
+---
+
+## Cross-Platform Patterns
+
+### 1. Tool Usage Pattern
+
+```markdown
+# Works across all platforms
+
+## Tool Strategy
+- Research before modifying
+- Read files before editing
+- Verify success before proceeding
+- Handle errors gracefully
+
+## Parallel Operations
+When tools are independent:
+- Run file reads in parallel
+- Batch similar operations
+- Don't wait unnecessarily
+
+When tools depend on each other:
+- Wait for results
+- Use output as input
+- Validate before proceeding
+```
+
+### 2. Task Tracking Pattern
+
+```markdown
+# Works across all platforms
+
+## Task Management
+For complex tasks (3+ steps):
+1. Create a task list
+2. Work through sequentially
+3. Mark complete when done
+4. Update user on progress
+
+## Progress Updates
+- Brief status after significant work
+- List completed items
+- Note remaining work
+- State next action
+```
+
+### 3. Error Handling Pattern
+
+```markdown
+# Works across all platforms
+
+## When Errors Occur
+1. Understand the error
+2. Read relevant context
+3. Plan a fix
+4. Implement solution
+5. Verify fix works
+
+## Don't
+- Give up immediately
+- Guess at solutions
+- Ignore error messages
+- Skip verification
+```
+
+---
+
+## AGENTS.md Template
+
+```markdown
+# AGENTS.md - Universal AI Agent Configuration
+
+> Configuration compatible with all AI coding assistants
+
+## Project Info
+- **Name**: [Project Name]
+- **Type**: [Web App / API / Library]
+- **Stack**: [TypeScript, React, etc.]
+
+## Code Style
+- TypeScript with strict mode
+- Functional patterns preferred
+- Async/await over Promise chains
+- Explicit error handling
+
+## Naming Conventions
+| Type | Convention | Example |
+|------|------------|---------|
+| Components | PascalCase | UserProfile |
+| Functions | camelCase | getUserData |
+| Constants | UPPER_SNAKE | API_URL |
+| Files | kebab-case | user-profile.tsx |
+
+## Best Practices
+- No `any` types
+- Small, focused functions
+- DRY principle
+- Test critical paths
+
+## Forbidden
+- console.log in production
+- Inline styles
+- Magic numbers
+- Direct state mutation
+
+## Security
+- No exposed secrets
+- Validate user input
+- Parameterized queries
+- Sanitize HTML output
+```
+
+---
+
+## Combining Platform Instructions
+
+### Option 1: Single AGENTS.md
+
+```markdown
+# AGENTS.md
+
+## Universal Instructions
+[Common to all platforms]
+
+## Platform-Specific
+<!-- Claude Code -->
+[Claude-specific additions]
+
+<!-- Cursor -->
+[Cursor-specific additions]
+
+<!-- Windsurf -->
+[Windsurf-specific additions]
+```
+
+### Option 2: Multiple Files
+
+```
+project/
+├── AGENTS.md              # Universal
+├── CLAUDE.md              # Claude Code specific
+├── .cursorrules           # Cursor specific
+├── .windsurfrules         # Windsurf specific
+└── .clinerules            # Cline specific
+```
+
+---
+
+## Best Practices Summary
+
+| Principle | Implementation |
+|-----------|---------------|
+| Universal Core | Common rules in AGENTS.md |
+| Platform Adapt | Specific files for each |
+| Consistency | Same conventions everywhere |
+| Specificity | Platform features in platform files |
+| Maintenance | Update AGENTS.md first, then sync |
+
+---
+
+## Using with namnam-skills
+
+```bash
+# Install platform configs
+npx namnam-skills platforms
+
+# Files generated:
+# - AGENTS.md (universal)
+# - .cursorrules (Cursor)
+# - .windsurfrules (Windsurf)
+# - .clinerules (Cline)
+```
+
+**Source**: Analysis of 30+ AI coding assistant system prompts