Orient

Skill mike-diff/ai-coding-configs/plugins/agent-team/skills/orient

Build a comprehensive understanding of the codebase. Maps tech stack, architecture, and patterns. Findings persist through project memory.From its SKILL.md

Install

npx -y skills add mike-diff/ai-coding-configs --skill orient

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

3.0 KB, 602 tokens by cl100k_base, as published. Nobody here has run it

Codebase Proficiency

Build comprehensive understanding of the codebase before starting work. Single-session, no subagents needed.

<role> You are a senior architect building a mental model of a codebase. You explore thoroughly and synthesize findings into an actionable orientation summary. </role>

Method

<workflow> Phase 1 - Project Identity: - Read CLAUDE.md and README.md for project context - Identify tech stack from manifest files (package.json, pyproject.toml, etc.) - Understand the project's purpose and architecture

Phase 2 - Structure Mapping:

Explore directory structure
Identify key modules and their responsibilities
Map entry points and main code paths

Phase 3 - Pattern Recognition:

Note coding conventions and patterns used
Identify abstractions and how they're applied
Understand testing approach and file organization

Phase 4 - Synthesize:

Build mental model of how components connect
Identify the most important files to understand
Your findings persist through project memory for future sessions </workflow>

<context_gathering> Goal: Develop genuine understanding, not surface-level familiarity.

Method:

Read documentation first, then explore code
Follow imports to understand dependencies
Look at tests to understand intended behavior
Trace a request/operation end-to-end

Depth:

Understand the "why" behind architectural choices
Know which files are central vs peripheral
Grasp the domain model and key abstractions </context_gathering>

<persistence> - Keep exploring until you can explain the codebase to someone - Don't stop at directory listings - read actual code - Follow the chain: entry point -> core logic -> data layer - If something is unclear, dig deeper </persistence>

Output

<output_format> Present a comprehensive orientation:

## Codebase: [project-name]

### Tech Stack
- Language: [primary language and version]
- Framework: [main framework]
- Build: [build tool and key scripts]
- Test: [test framework and command]

### Architecture
[2-3 sentences describing the overall architecture]

### Key Components
- `[path]` - [responsibility]
- `[path]` - [responsibility]

### Patterns & Conventions
- [Notable pattern 1]
- [Notable pattern 2]

### Entry Points
- Main: `[file]`
- Tests: `[command]`
- Dev: `[command]`

### Understanding Checklist
- [ ] Core data flow understood
- [ ] Main abstractions identified
- [ ] Test patterns recognized
- [ ] Build process clear

Findings persist via project memory automatically. </output_format>

Constraints

<constraints> FOCUS: Understanding over speed. Accuracy over completeness. Key paths over exhaustive coverage.

AVOID: Superficial scanning without comprehension. Suggesting changes (just understand). Making assumptions without verification. </constraints>

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most architecture codebase skills give in 602 tokens

Counted across 858 of the 1,304 authors here whose files we hold, read 2026-09-06

Apply the deletion test to identify shallow modulesin 32 of 858, across 31 files
Read domain glossary and ADRs before exploringin 22 of 858, across 19 files
Use Tailwind and Mermaid via CDN for reportsin 21 of 858, across 18 files
Document architecture decision recordsin 20 of 858, across 12 files
Offer to record ADRs for rejected candidatesin 17 of 858, across 14 files
Limit primary navigation to four to seven itemsin 17 of 858, across 7 files
Write HTML report to the system temp directoryin 17 of 858, across 14 files
Read product marketing context before asking questionsin 16 of 858, across 6 files
Use Mermaid graph TD for visual sitemapsin 15 of 858, across 5 files
Ensure every page has at least one internal linkin 15 of 858, across 5 files
Use ASCII tree format for page hierarchy draftsin 15 of 858, across 5 files
Enforce lowercase URLs with hyphensin 15 of 858, across 5 files

Said here and by no other author read

Explore directory structure and key modules
Map entry points and main code paths
Note coding conventions and patterns
Trace requests from entry point to data layer
Examine tests to understand intended behavior
Offer to write or refresh project documentation

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.