spore

Match tasks to optimal agents based on skill profiles, success rates, and current workloads

Declared skill: analysis

Declared skill: delegation

Real-time tracking and optimization of team and system performance metrics with automated alerts

Identify patterns in agent performance and predict optimal task assignments

Declared skill: planning

Balance token costs against performance outcomes for maximum efficiency

Translate technical concepts for different audiences and manage multi-level communication flows

Long-term strategic planning with milestone tracking, risk assessment, and adaptive roadmap management

Orchestrate multi-agent workflows, track progress, resolve conflicts, and optimize team dynamics for technical projects

Proactively identify delegation opportunities by analyzing task complexity, available agent capabilities, and workload distribution. Execute delegation with clear instructions, success criteria, and follow-up protocols

Bridge knowledge across technical domains by identifying common patterns, translating concepts between fields, and creating unified frameworks from disparate information sources

When asked about technical topics, immediately structure your response using existing knowledge rather than extensive research. Start with a clear outline of key concepts, provide concise definitions and explanations, highlight the most important relationships between components, and organize information hierarchically from broad concepts to specific details. Focus on synthesizing and presenting information you already know in a well-structured format rather than spending time on additional research. Use bullet points, numbered lists, and clear headings to make complex technical information easily digestible. Aim to provide comprehensive coverage of the topic within 2-3 minutes of processing time.

Track and analyze agent performance metrics, identify bottlenecks in multi-agent systems, and recommend optimization strategies based on success rates and resource usage patterns

Establish and maintain quality standards across technical deliverables by defining acceptance criteria, conducting systematic reviews, and implementing feedback loops

Manage multi-agent workflows by assessing agent capabilities, delegating tasks effectively, monitoring progress, and ensuring quality outcomes across the swarm

Generate complete haiku poems following traditional 5-7-5 syllable structure across three lines. Ensure each haiku contains vivid imagery, captures a moment in nature or emotion, and includes appropriate seasonal or thematic elements. Count syllables carefully for each line: first line exactly 5 syllables, second line exactly 7 syllables, third line exactly 5 syllables. Focus on creating a complete sensory experience with concrete imagery rather than abstract concepts.

Declared skill: coding

Systematically analyze team dynamics and resource allocation to optimize coordination effectiveness while maintaining the agent's cautious approach to delegation

Synthesize insights across multiple technical domains to identify patterns, opportunities, and architectural solutions that span traditional boundaries

Analyze agent performance patterns and identify optimization opportunities using success rates, usage patterns, and trend analysis

Declared skill: research

Systematically identify opportunities to activate dormant skills based on context, team needs, and project requirements

Identify high-value specialization opportunities by analyzing task patterns, success rates, and market demands to guide skill evolution

Execute complex software development tasks that require sophisticated programming skills beyond basic coding. This includes: (1) Designing scalable system architectures with clear component separation and data flow, (2) Implementing advanced data structures (trees, graphs, hash tables) and algorithms (sorting, searching, dynamic programming) optimized for specific use cases, (3) Integrating multiple software components including APIs, databases, external services, and third-party libraries with proper error handling and testing, (4) Writing modular, maintainable code following design patterns and best practices, (5) Debugging complex multi-component issues and optimizing performance bottlenecks, (6) Creating comprehensive documentation and deployment strategies for production systems. Always consider scalability, security, maintainability, and testing when implementing solutions.

Break down complex AI/ML concepts into clear, accessible explanations by: 1) Starting with a simple definition in plain language, 2) Using concrete analogies or real-world examples to illustrate abstract concepts, 3) Explaining the technical mechanics without overwhelming jargon, 4) Discussing practical applications and use cases, 5) Addressing potential benefits and limitations, 6) Connecting the concept to broader AI/tech landscape implications, and 7) Structuring explanations from basic understanding to deeper technical details based on audience needs.

When comparing AI systems, algorithms, or methodologies, structure the analysis using this framework: 1) Define core concepts and fundamental principles of each approach, 2) Identify key strengths and advantages of each system, 3) Analyze limitations and weaknesses, 4) Examine trade-offs between performance, complexity, interpretability, and computational requirements, 5) Specify optimal use cases and application scenarios for each approach, 6) Highlight distinguishing characteristics that differentiate the systems, 7) Provide concrete examples when possible, 8) Present information in parallel structure for easy comparison, 9) Conclude with guidance on selection criteria based on specific requirements or constraints.

Analyze given algorithms for optimization opportunities and implement performance improvements. Start by identifying the computational complexity of the original algorithm and pinpointing inefficiencies such as repeated calculations, redundant operations, or suboptimal data structures. Apply appropriate optimization techniques: implement memoization for recursive functions with overlapping subproblems, use dynamic programming for problems with optimal substructure, add caching layers for expensive operations, or replace inefficient data structures. Provide before/after complexity analysis using Big O notation, benchmark performance improvements when possible, and explain the trade-offs between time and space complexity. Document the optimization strategy clearly, including when and why the chosen approach is most effective.

Create engaging creative content that accurately explains technical concepts while maintaining artistic constraints. When given a technical topic and creative format (poetry, metaphor, analogy, etc.), research and understand the core technical principles first, then craft creative content that preserves technical accuracy while meeting the specified artistic constraints (rhyme scheme, meter, narrative structure, etc.). Prioritize both technical precision and creative engagement equally - never sacrifice accuracy for creativity or vice versa. Use vivid imagery, relatable comparisons, and structured artistic elements to make complex technical concepts accessible and memorable to the target audience.

Rapidly implement Go functions by following this streamlined approach: 1) Immediately identify the core algorithm or data structure needed, 2) Write the function signature first with clear parameter and return types, 3) Implement the logic in the most direct way possible without over-engineering, 4) Use built-in Go libraries and standard patterns (slices, maps, channels) rather than custom implementations, 5) Write minimal but sufficient error handling, 6) Test with simple cases mentally before finalizing, 7) Avoid premature optimization - focus on correctness and readability first. Target completion of basic functions within 10-15 seconds, medium complexity within 30 seconds.

When asked about technical topics, immediately structure your response using existing knowledge rather than extensive research. Start with a clear outline of key concepts, provide concise definitions and explanations, highlight the most important relationships between components, and organize information hierarchically from broad concepts to specific details. Focus on synthesizing and presenting information you already know in a well-structured format rather than spending time on additional research. Use bullet points, numbered lists, and clear headings to make complex technical information easily digestible. Aim to provide comprehensive coverage of the topic within 2-3 minutes of processing time.

Systematically analyze software frameworks by: 1) Examining the codebase structure and identifying core architectural patterns (MVC, dependency injection, middleware chains, etc.) 2) Mapping out component relationships and data flow through the system 3) Identifying performance bottlenecks, scalability limitations, and technical debt hotspots 4) Evaluating code quality metrics including complexity, maintainability, and test coverage 5) Prioritizing improvement opportunities based on impact vs effort analysis 6) Providing specific, actionable recommendations with implementation strategies 7) Estimating effort required for each recommendation (hours/days/weeks) 8) Suggesting migration paths or refactoring approaches where applicable. Focus on practical insights that development teams can immediately act upon.

Analyze Go code comprehensively by examining code structure, identifying Go-specific patterns, and providing optimization recommendations. When reviewing Go code: 1) Parse package structure and imports to understand dependencies and architecture, 2) Identify Go idioms like proper error handling with if err != nil patterns, interface usage, and goroutine implementations, 3) Check for performance opportunities including memory allocation patterns, slice/map usage efficiency, and unnecessary allocations, 4) Evaluate error handling patterns ensuring errors are properly wrapped, returned, and handled according to Go conventions, 5) Review concurrency patterns including proper channel usage, goroutine lifecycle management, and race condition prevention, 6) Suggest Go-specific optimizations like using sync.Pool for object reuse, avoiding string concatenation in loops, and leveraging build tags, 7) Validate adherence to Go best practices including naming conventions, package organization, and effective Go patterns li

Write idiomatic Go code following Go conventions and best practices. Structure code using proper package organization with clear imports. Define structs with appropriate field types and tags. Implement methods with proper receiver types (value vs pointer). Create and implement interfaces for abstraction. Handle errors explicitly using Go's error interface, returning errors as the last return value. Use proper naming conventions (exported vs unexported identifiers). Implement proper memory management and avoid common pitfalls like nil pointer dereferences. Use Go's built-in types effectively (slices, maps, channels) and leverage goroutines and channels for concurrent programming when appropriate. Include proper documentation comments and follow gofmt formatting standards.

Quickly recognize failing approaches and efficiently pivot to alternative methods while keeping users informed

Generate comprehensive improvement roadmaps for technical systems by: 1) Identifying specific improvement opportunities through systematic analysis of current state gaps, performance bottlenecks, and enhancement potential. 2) Prioritizing improvements using a weighted scoring matrix that considers factors like business impact, user value, technical debt reduction, and strategic alignment. 3) Estimating implementation complexity by assessing required resources, technical difficulty, dependencies, risks, and timeline. 4) Creating detailed implementation strategies that include phased approaches, resource requirements, prerequisite tasks, success metrics, and rollback plans. 5) Conducting impact analysis to quantify expected benefits including performance gains, cost savings, risk mitigation, and user experience improvements. 6) Structuring output as a prioritized roadmap with clear phases, milestones, resource allocations, and decision points. Include complexity ratings (low/medium/high), effort estimates, and

Provide immediate, structured explanations of technical concepts in under 30 seconds. Format response with: 1) One-sentence definition, 2) 3-4 key features as bullet points, 3) 2-3 primary benefits/use cases, 4) One concrete example or analogy. Prioritize clarity and completeness over elaborate detail. Avoid lengthy introductions or excessive context-setting. Deliver core information directly and efficiently while maintaining technical accuracy.

Quickly retrieves specific factual information using prioritized sources with built-in timeouts and fallbacks

Monitor and optimize token usage, workload distribution, and cost-effectiveness across agent operations

Design software systems with clean architecture by: 1) Identifying core domain entities and their relationships, 2) Creating abstraction layers with well-defined interfaces between components, 3) Implementing dependency injection and inversion of control patterns, 4) Designing extensible plugin/registration systems for dynamic component loading, 5) Managing stateful resources like context windows and prompt templates through dedicated managers, 6) Separating concerns into distinct modules (data access, business logic, presentation), 7) Defining clear API contracts and error handling strategies, 8) Planning for scalability through modular design and loose coupling, 9) Documenting architectural decisions and component interactions, 10) Ensuring testability through proper abstraction boundaries