@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/threejs.md

@@ -0,0 +1,89 @@
+---
+name: threejs
+description: Build immersive 3D web experiences with Three.js - WebGL/WebGPU library for scenes, cameras, geometries, materials, lights, animations, loaders, post-processing, shaders (including node-based TSL), compute, physics, VR/XR, and advanced rendering. Use when creating 3D visualizations, games, interactive graphics, data viz, product configurators, architectural walkthroughs, or WebGL/WebGPU applications. Covers OrbitControls, GLTF/FBX loading, PBR materials, shadow mapping, post-processing effects (bloom, SSAO, SSR), custom shaders, instancing, LOD, animation systems, and WebXR.
+license: MIT
+version: 1.0.0
+---
+
+# Three.js Development
+
+Build high-performance 3D web applications using Three.js - a cross-browser WebGL/WebGPU library.
+
+## When to Use This Skill
+
+Use when working with:
+- 3D scenes, models, animations, or visualizations
+- WebGL/WebGPU rendering and graphics programming
+- Interactive 3D experiences (games, configurators, data viz)
+- Camera controls, lighting, materials, or shaders
+- Loading 3D assets (GLTF, FBX, OBJ) or textures
+- Post-processing effects (bloom, depth of field, SSAO)
+- Physics simulations, VR/XR experiences, or spatial audio
+- Performance optimization (instancing, LOD, frustum culling)
+
+## Progressive Learning Path
+
+### Level 1: Getting Started
+Load `references/01-getting-started.md` - Scene setup, basic geometries, materials, lights, rendering loop
+
+### Level 2: Common Tasks
+- **Asset Loading**: `references/02-loaders.md` - GLTF, FBX, OBJ, texture loaders
+- **Textures**: `references/03-textures.md` - Types, mapping, wrapping, filtering
+- **Cameras**: `references/04-cameras.md` - Perspective, orthographic, controls
+- **Lights**: `references/05-lights.md` - Types, shadows, helpers
+- **Animations**: `references/06-animations.md` - Clips, mixer, keyframes
+- **Math**: `references/07-math.md` - Vectors, matrices, quaternions, curves
+
+### Level 3: Interactive & Effects
+- **Interaction**: `references/08-interaction.md` - Raycasting, picking, transforms
+- **Post-Processing**: `references/09-postprocessing.md` - Passes, bloom, SSAO, SSR
+- **Controls (Addons)**: `references/10-controls.md` - Orbit, transform, first-person
+
+### Level 4: Advanced Rendering
+- **Materials Advanced**: `references/11-materials-advanced.md` - PBR, custom shaders
+- **Performance**: `references/12-performance.md` - Instancing, LOD, batching, culling
+- **Node Materials (TSL)**: `references/13-node-materials.md` - Shader graphs, compute
+
+### Level 5: Specialized
+- **Physics**: `references/14-physics-vr.md` - Ammo, Rapier, Jolt, VR/XR
+- **Advanced Loaders**: `references/15-specialized-loaders.md` - SVG, VRML, domain-specific
+- **WebGPU**: `references/16-webgpu.md` - Modern backend, compute shaders
+
+## Quick Start Pattern
+
+```javascript
+// 1. Scene, Camera, Renderer
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
+const renderer = new THREE.WebGLRenderer();
+renderer.setSize(window.innerWidth, window.innerHeight);
+document.body.appendChild(renderer.domElement);
+
+// 2. Add Objects
+const geometry = new THREE.BoxGeometry();
+const material = new THREE.MeshStandardMaterial({ color: 0x00ff00 });
+const cube = new THREE.Mesh(geometry, material);
+scene.add(cube);
+
+// 3. Add Lights
+const light = new THREE.DirectionalLight(0xffffff, 1);
+light.position.set(5, 5, 5);
+scene.add(light);
+scene.add(new THREE.AmbientLight(0x404040));
+
+// 4. Animation Loop
+function animate() {
+  requestAnimationFrame(animate);
+  cube.rotation.x += 0.01;
+  cube.rotation.y += 0.01;
+  renderer.render(scene, camera);
+}
+animate();
+```
+
+## External Resources
+
+- Official Docs: https://threejs.org/docs/
+- Examples: https://threejs.org/examples/
+- Editor: https://threejs.org/editor/
+- Discord: https://discord.gg/56GBJwAnUS

package/merged-commands/tool-design.md

@@ -0,0 +1,318 @@
+---
+name: tool-design
+description: "Build tools that agents can use effectively, including architectural reduction patterns"
+source: "https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/tool-design"
+risk: safe
+---
+
+## When to Use This Skill
+
+Build tools that agents can use effectively, including architectural reduction patterns
+
+Use this skill when working with build tools that agents can use effectively, including architectural reduction patterns.
+# Tool Design for Agents
+
+Tools are the primary mechanism through which agents interact with the world. They define the contract between deterministic systems and non-deterministic agents. Unlike traditional software APIs designed for developers, tool APIs must be designed for language models that reason about intent, infer parameter values, and generate calls from natural language requests. Poor tool design creates failure modes that no amount of prompt engineering can fix. Effective tool design follows specific principles that account for how agents perceive and use tools.
+
+## When to Activate
+
+Activate this skill when:
+- Creating new tools for agent systems
+- Debugging tool-related failures or misuse
+- Optimizing existing tool sets for better agent performance
+- Designing tool APIs from scratch
+- Evaluating third-party tools for agent integration
+- Standardizing tool conventions across a codebase
+
+## Core Concepts
+
+Tools are contracts between deterministic systems and non-deterministic agents. The consolidation principle states that if a human engineer cannot definitively say which tool should be used in a given situation, an agent cannot be expected to do better. Effective tool descriptions are prompt engineering that shapes agent behavior.
+
+Key principles include: clear descriptions that answer what, when, and what returns; response formats that balance completeness and token efficiency; error messages that enable recovery; and consistent conventions that reduce cognitive load.
+
+## Detailed Topics
+
+### The Tool-Agent Interface
+
+**Tools as Contracts**
+Tools are contracts between deterministic systems and non-deterministic agents. When humans call APIs, they understand the contract and make appropriate requests. Agents must infer the contract from descriptions and generate calls that match expected formats.
+
+This fundamental difference requires rethinking API design. The contract must be unambiguous, examples must illustrate expected patterns, and error messages must guide correction. Every ambiguity in tool definitions becomes a potential failure mode.
+
+**Tool Description as Prompt**
+Tool descriptions are loaded into agent context and collectively steer behavior. The descriptions are not just documentation—they are prompt engineering that shapes how agents reason about tool use.
+
+Poor descriptions like "Search the database" with cryptic parameter names force agents to guess. Optimized descriptions include usage context, examples, and defaults. The description answers: what the tool does, when to use it, and what it produces.
+
+**Namespacing and Organization**
+As tool collections grow, organization becomes critical. Namespacing groups related tools under common prefixes, helping agents select appropriate tools at the right time.
+
+Namespacing creates clear boundaries between functionality. When an agent needs database information, it routes to the database namespace. When it needs web search, it routes to web namespace.
+
+### The Consolidation Principle
+
+**Single Comprehensive Tools**
+The consolidation principle states that if a human engineer cannot definitively say which tool should be used in a given situation, an agent cannot be expected to do better. This leads to a preference for single comprehensive tools over multiple narrow tools.
+
+Instead of implementing list_users, list_events, and create_event, implement schedule_event that finds availability and schedules. The comprehensive tool handles the full workflow internally rather than requiring agents to chain multiple calls.
+
+**Why Consolidation Works**
+Agents have limited context and attention. Each tool in the collection competes for attention in the tool selection phase. Each tool adds description tokens that consume context budget. Overlapping functionality creates ambiguity about which tool to use.
+
+Consolidation reduces token consumption by eliminating redundant descriptions. It eliminates ambiguity by having one tool cover each workflow. It reduces tool selection complexity by shrinking the effective tool set.
+
+**When Not to Consolidate**
+Consolidation is not universally correct. Tools with fundamentally different behaviors should remain separate. Tools used in different contexts benefit from separation. Tools that might be called independently should not be artificially bundled.
+
+### Architectural Reduction
+
+The consolidation principle, taken to its logical extreme, leads to architectural reduction: removing most specialized tools in favor of primitive, general-purpose capabilities. Production evidence shows this approach can outperform sophisticated multi-tool architectures.
+
+**The File System Agent Pattern**
+Instead of building custom tools for data exploration, schema lookup, and query validation, provide direct file system access through a single command execution tool. The agent uses standard Unix utilities (grep, cat, find, ls) to explore, understand, and operate on your system.
+
+This works because:
+1. File systems are a proven abstraction that models understand deeply
+2. Standard tools have predictable, well-documented behavior
+3. The agent can chain primitives flexibly rather than being constrained to predefined workflows
+4. Good documentation in files replaces the need for summarization tools
+
+**When Reduction Outperforms Complexity**
+Reduction works when:
+- Your data layer is well-documented and consistently structured
+- The model has sufficient reasoning capability to navigate complexity
+- Your specialized tools were constraining rather than enabling the model
+- You're spending more time maintaining scaffolding than improving outcomes
+
+Reduction fails when:
+- Your underlying data is messy, inconsistent, or poorly documented
+- The domain requires specialized knowledge the model lacks
+- Safety constraints require limiting what the agent can do
+- Operations are truly complex and benefit from structured workflows
+
+**Stop Constraining Reasoning**
+A common anti-pattern is building tools to "protect" the model from complexity. Pre-filtering context, constraining options, wrapping interactions in validation logic. These guardrails often become liabilities as models improve.
+
+The question to ask: are your tools enabling new capabilities, or are they constraining reasoning the model could handle on its own?
+
+**Build for Future Models**
+Models improve faster than tooling can keep up. An architecture optimized for today's model may be over-constrained for tomorrow's. Build minimal architectures that can benefit from model improvements rather than sophisticated architectures that lock in current limitations.
+
+See [Architectural Reduction Case Study](./references/architectural_reduction.md) for production evidence.
+
+### Tool Description Engineering
+
+**Description Structure**
+Effective tool descriptions answer four questions:
+
+What does the tool do? Clear, specific description of functionality. Avoid vague language like "helps with" or "can be used for." State exactly what the tool accomplishes.
+
+When should it be used? Specific triggers and contexts. Include both direct triggers ("User asks about pricing") and indirect signals ("Need current market rates").
+
+What inputs does it accept? Parameter descriptions with types, constraints, and defaults. Explain what each parameter controls.
+
+What does it return? Output format and structure. Include examples of successful responses and error conditions.
+
+**Default Parameter Selection**
+Defaults should reflect common use cases. They reduce agent burden by eliminating unnecessary parameter specification. They prevent errors from omitted parameters.
+
+### Response Format Optimization
+
+Tool response size significantly impacts context usage. Implementing response format options gives agents control over verbosity.
+
+Concise format returns essential fields only, appropriate for confirmation or basic information. Detailed format returns complete objects with all fields, appropriate when full context is needed for decisions.
+
+Include guidance in tool descriptions about when to use each format. Agents learn to select appropriate formats based on task requirements.
+
+### Error Message Design
+
+Error messages serve two audiences: developers debugging issues and agents recovering from failures. For agents, error messages must be actionable. They must tell the agent what went wrong and how to correct it.
+
+Design error messages that enable recovery. For retryable errors, include retry guidance. For input errors, include corrected format. For missing data, include what's needed.
+
+### Tool Definition Schema
+
+Use a consistent schema across all tools. Establish naming conventions: verb-noun pattern for tool names, consistent parameter names across tools, consistent return field names.
+
+### Tool Collection Design
+
+Research shows tool description overlap causes model confusion. More tools do not always lead to better outcomes. A reasonable guideline is 10-20 tools for most applications. If more are needed, use namespacing to create logical groupings.
+
+Implement mechanisms to help agents select the right tool: tool grouping, example-based selection, and hierarchy with umbrella tools that route to specialized sub-tools.
+
+### MCP Tool Naming Requirements
+
+When using MCP (Model Context Protocol) tools, always use fully qualified tool names to avoid "tool not found" errors.
+
+Format: `ServerName:tool_name`
+
+```python
+# Correct: Fully qualified names
+"Use the BigQuery:bigquery_schema tool to retrieve table schemas."
+"Use the GitHub:create_issue tool to create issues."
+
+# Incorrect: Unqualified names
+"Use the bigquery_schema tool..."  # May fail with multiple servers
+```
+
+Without the server prefix, agents may fail to locate tools, especially when multiple MCP servers are available. Establish naming conventions that include server context in all tool references.
+
+### Using Agents to Optimize Tools
+
+Claude can optimize its own tools. When given a tool and observed failure modes, it diagnoses issues and suggests improvements. Production testing shows this approach achieves 40% reduction in task completion time by helping future agents avoid mistakes.
+
+**The Tool-Testing Agent Pattern**:
+
+```python
+def optimize_tool_description(tool_spec, failure_examples):
+    """
+    Use an agent to analyze tool failures and improve descriptions.
+    
+    Process:
+    1. Agent attempts to use tool across diverse tasks
+    2. Collect failure modes and friction points
+    3. Agent analyzes failures and proposes improvements
+    4. Test improved descriptions against same tasks
+    """
+    prompt = f"""
+    Analyze this tool specification and the observed failures.
+    
+    Tool: {tool_spec}
+    
+    Failures observed:
+    {failure_examples}
+    
+    Identify:
+    1. Why agents are failing with this tool
+    2. What information is missing from the description
+    3. What ambiguities cause incorrect usage
+    
+    Propose an improved tool description that addresses these issues.
+    """
+    
+    return get_agent_response(prompt)
+```
+
+This creates a feedback loop: agents using tools generate failure data, which agents then use to improve tool descriptions, which reduces future failures.
+
+### Testing Tool Design
+
+Evaluate tool designs against criteria: unambiguity, completeness, recoverability, efficiency, and consistency. Test tools by presenting representative agent requests and evaluating the resulting tool calls.
+
+## Practical Guidance
+
+### Anti-Patterns to Avoid
+
+Vague descriptions: "Search the database for customer information" leaves too many questions unanswered.
+
+Cryptic parameter names: Parameters named x, val, or param1 force agents to guess meaning.
+
+Missing error handling: Tools that fail with generic errors provide no recovery guidance.
+
+Inconsistent naming: Using id in some tools, identifier in others, and customer_id in some creates confusion.
+
+### Tool Selection Framework
+
+When designing tool collections:
+1. Identify distinct workflows agents must accomplish
+2. Group related actions into comprehensive tools
+3. Ensure each tool has a clear, unambiguous purpose
+4. Document error cases and recovery paths
+5. Test with actual agent interactions
+
+## Examples
+
+**Example 1: Well-Designed Tool**
+```python
+def get_customer(customer_id: str, format: str = "concise"):
+    """
+    Retrieve customer information by ID.
+    
+    Use when:
+    - User asks about specific customer details
+    - Need customer context for decision-making
+    - Verifying customer identity
+    
+    Args:
+        customer_id: Format "CUST-######" (e.g., "CUST-000001")
+        format: "concise" for key fields, "detailed" for complete record
+    
+    Returns:
+        Customer object with requested fields
+    
+    Errors:
+        NOT_FOUND: Customer ID not found
+        INVALID_FORMAT: ID must match CUST-###### pattern
+    """
+```
+
+**Example 2: Poor Tool Design**
+
+This example demonstrates several tool design anti-patterns:
+
+```python
+def search(query):
+    """Search the database."""
+    pass
+```
+
+**Problems with this design:**
+
+1. **Vague name**: "search" is ambiguous - search what, for what purpose?
+2. **Missing parameters**: What database? What format should query take?
+3. **No return description**: What does this function return? A list? A string? Error handling?
+4. **No usage context**: When should an agent use this versus other tools?
+5. **No error handling**: What happens if the database is unavailable?
+
+**Failure modes:**
+- Agents may call this tool when they should use a more specific tool
+- Agents cannot determine correct query format
+- Agents cannot interpret results
+- Agents cannot recover from failures
+
+## Guidelines
+
+1. Write descriptions that answer what, when, and what returns
+2. Use consolidation to reduce ambiguity
+3. Implement response format options for token efficiency
+4. Design error messages for agent recovery
+5. Establish and follow consistent naming conventions
+6. Limit tool count and use namespacing for organization
+7. Test tool designs with actual agent interactions
+8. Iterate based on observed failure modes
+9. Question whether each tool enables or constrains the model
+10. Prefer primitive, general-purpose tools over specialized wrappers
+11. Invest in documentation quality over tooling sophistication
+12. Build minimal architectures that benefit from model improvements
+
+## Integration
+
+This skill connects to:
+- context-fundamentals - How tools interact with context
+- multi-agent-patterns - Specialized tools per agent
+- evaluation - Evaluating tool effectiveness
+
+## References
+
+Internal references:
+- [Best Practices Reference](./references/best_practices.md) - Detailed tool design guidelines
+- [Architectural Reduction Case Study](./references/architectural_reduction.md) - Production evidence for tool minimalism
+
+Related skills in this collection:
+- context-fundamentals - Tool context interactions
+- evaluation - Tool testing patterns
+
+External resources:
+- MCP (Model Context Protocol) documentation
+- Framework tool conventions
+- API design best practices for agents
+- Vercel d0 agent architecture case study
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2025-12-23
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.1.0