explore

Map task concerns and read relevant files before planning code placement.

Updated Feb 7, 2026

Search Tags:#workflow #planning #architecture #code analysis #exploration #pre-implementation

Ready to run

npx skills add https://github.com/sylin-org/koi --skill explore-sylin-org

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: explore
Source: https://github.com/sylin-org/koi/tree/main/.codex/skills/explore
Command: npx skills add https://github.com/sylin-org/koi --skill explore-sylin-org

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures a thorough understanding of a task's scope and existing codebase before writing new production code, preventing architectural drift and ensuring efficient implementation.

Core Features & Use Cases

Task Decomposition: Breaks down tasks by identifying affected crates, layers, and expected outcomes.
Codebase Analysis: Guides the systematic reading of relevant files to understand existing patterns and logic.
Pattern Identification: Helps in finding the closest existing implementation to follow, promoting consistency.
Architectural Guardrails: Verifies adherence to project conventions and dependency rules.
Use Case: Before adding a new feature to the mDNS discovery module, this Skill would be used to analyze existing mDNS code, identify relevant types and constants, and plan the exact file locations for the new implementation.

Quick Start

Use the explore skill to analyze the task of adding a new CLI command for service announcements.

Frequently Asked Questions about explore

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

What is pre-implementation codebase exploration and why is it needed before coding?▼

Pre-implementation exploration maps task concerns, reads relevant files, and checks existing patterns to ensure production code is only written after fully understanding the codebase, preventing architectural drift.

How do I plan code placement for a new feature in an existing software architecture?▼

To plan code placement, you map the task's affected layers, read relevant files to identify existing constants and types, find the closest existing implementation pattern, and verify adherence to architectural guardrails.

How do I analyze existing code patterns to maintain consistency when adding new features?▼

Analyze existing code patterns by systematically reading relevant files, checking existing types and constants, and identifying the closest existing implementation to follow, which promotes consistency across the codebase.

Can I use a pre-implementation workflow to check architectural guardrails and dependency rules?▼

Yes, a pre-implementation workflow verifies adherence to project conventions and architectural dependency rules by mapping task layers and analyzing relevant files before any production code is written.

When should I not use a mandatory code analysis workflow before writing production code?▼

A mandatory code analysis workflow is not needed for trivial changes that do not affect existing architectural layers, as its primary purpose is to map concerns and prevent architectural drift during substantial feature implementation.

What's the best way to decompose a software task into affected crates and layers before implementation?▼

The best way to decompose a task is to map its concerns by identifying affected crates, layers, and expected outcomes, ensuring a comprehensive understanding of the task scope before writing code.