Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

explore

/explore

Prowadzi obowiązkową eksplorację przed implementacją w Koan (.NET/C#): mapuje warstwy, czyta pliki i dokumentację, sprawdza istniejące typy i wzorce oraz planuje dokładne miejsce kodu.

Repozytorium
koan-framework ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
27.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Prowadzi obowiązkową eksplorację przed implementacją w Koan (.NET/C#): mapuje warstwy, czyta pliki i dokumentację, sprawdza istniejące typy i wzorce oraz planuje dokładne miejsce kodu.

Oryginalny opis (EN)

Run a mandatory pre-implementation exploration workflow before writing production code in Koan (.NET/C#). Use when a task requires code changes and Codex must first map concerns/layers, read relevant files and docs, check existing constants and types, identify the closest existing pattern, plan exact code placement, and confirm architectural guardrails.

Jak działa

  1. Global constraints (must hold)
  2. Step 1: Understand the task
  3. Step 2: Map the project and read core docs
  4. Step 3: Read existing code
  5. Step 4: Check for existing constants, options, and shared types
  6. Step 5: Interrogate the closest pattern and coalescence boundary
  7. Step 6: Plan where new code will live
  8. Step 7: Check for potential violations
  9. Step 8: Present the plan
Sekcje z nagłówków SKILL.md, w oryginale · 174 linii, 1 119 słów
Podgląd SKILL.md
---
name: explore
description: Run a mandatory pre-implementation exploration workflow before writing production code in Koan (.NET/C#). Use when a task requires code changes and Codex must first map concerns/layers, read relevant files and docs, check existing constants and types, identify the closest existing pattern, plan exact code placement, and confirm architectural guardrails.
---

# Explore

Before implementing anything for a task, complete the following steps in order.
Do not write production code until all steps are done.

## Global constraints (must hold)

- Entity-first data access: prefer `Entity<T>` statics; avoid repositories and `Data<TEntity,TKey>` unless no static exists.
- Controllers-only HTTP: no inline endpoints (`MapGet`/`MapPost`/etc) unless an ADR explicitly allows it.
- No magic literals: stable identifiers go in `Infrastructure/Constants`; tunables are typed `*Options`.
- Environment posture: gate capabilities through `KoanEnv.Gate` — a `KoanMagic` for a convenience that is
  risky only in production (Production is the gate, so Staging/Test/CI still run it), `DevelopmentOnly`
  for a surface nothing may unlock — never a raw `IsDevelopment()`/`IsProduction()`. Diagnostics may
  read directly; a guard spec enumerates every exception (ARCH-0128).
- Docs posture: instruction-first (no tutorials); update ADRs and TOCs when behavior/policy changes.
- Per-project docs: `README.md` + `TECHNICAL.md` at project roots for reusable modules.
- Large data paths: use capability-qualified streaming or explicit paging. InMemory, JSON, and Redis
  reject `AllStream`/`QueryStream`; see DATA-0107.

## Step 1: Understand the task

Restate the task in your own words. Identify:
- What concern this touches: data access, web API, messaging, hosting, adapters, tooling, docs
- Which layer is involved: controllers, core logic, options/config, storage, adapters
- Expected output: new feature, refactor, bug fix, doc update

For application-facing capability work, state before internal design:

- the user's business sentence;
- the smallest honest C# expression and complete user action surface—references, code, decorations,
  configuration, context, and runtime prerequisites—of it;
- the guarantee that expression creates and the corrective failure when it cannot be met; and
- every additional public concept and why the business or guarantee requires it.

Use `AddKoan()` / `Entity<T>` / `EntityController<T>` as the golden business-to-code comparison. Exact
compactness is not always possible, but framework assembly machinery must not leak into the common path.
Minimize distinct concepts and cognitive branches, not physical lines or tokens; hidden prerequisites count.

## Step 2: Map the project and read core docs

Open and read the 3-5 most relevant documentation files and entry points.
Start with:

- docs/engineering/README.md
- docs/architecture/principles.md
- docs/toc.yml
- README.md

If the task touches specific areas, add the relevant ADR or guide, for example:

- docs/decisions/DATA-0107-provider-bounded-entity-streams.md
- docs/decisions/WEB-0035-entitycontroller-transformers.md
- docs/guides/data/entity-access-and-streaming.md

For each file read, state in one sentence what it establishes and whether it is relevant.

## Step 3: Read existing code

Open and read the 3-5 most relevant existing source files.
Use searches like:

```bash
# Find existing controllers and HTTP patterns
rg "class .*Controller" src/ samples/ -g"*.cs"
rg "\[ApiController\]|\[Route\(" src/ samples/ -g"*.cs"

# Find data access patterns (prefer model statics)
rg "\.All\(|\.Query\(|\.AllStream\(|\.QueryStream\(|\.FirstPage\(|\.Page\(" src/ samples/ -g"*.cs"

# Find options and constants
rg "class .*Options|record .*Options" src/ samples/ -g"*.cs"
rg "class Constants|static class Constants" src/ samples/ -g"*.cs"

# Find similar domain types
rg "class|record|interface" src/ samples/ -g"*.cs"
```

For each file read, state in one sentence what it does and whether it is relevant.

## Step 4: Check for existing constants, options, and shared types

Run these searches explicitly and report results:

```bash
# Constants that might already exist
rg "\bconst\b" src/ samples/ -g"*.cs"
rg "\bConstants\b" src/ samples/ -g"*.cs"

# Options types that might already exist
rg "\bOptions\b" src/ samples/ -g"*.cs"

# Shared DTOs or contracts
rg "record|class .*Dto|class .*Request|class .*Response" src/ samples/ -g"*.cs"
```

For each required piece of functionality, state clearly:
- `Already exists`
- `Needs to be created`

## Step 5: Interrogate the closest pattern and coalescence boundary

Find the most similar existing feature in the codebase.
Examples:
- New HTTP endpoint: read an existing `*Controller.cs` in `src/` or `samples/`
- New data access: read a model using `All`, `Query`, or paging statics
- New options/config: read a feature using `*Options`
- New adapter: read the closest adapter in `src/` or `samples/`

The closest pattern is evidence, not authority. Compare it with sibling mechanisms and state:

- `Closest pattern: [specific file]`
- current decision owner, consumers, state lifetime, and hot-path cost;
- repeated mechanics elsewhere;
- chosen specificity: framework law, capability family, pillar, adapter, or application;
- disposition: `keep`, `absorb`, `rebuild`, or `delete`;
- the one target owner and why the next wider/narrower owner is wrong;
- human readability, IntelliSense discovery, and coding-model legibility; and
- superseded paths that the slice must delete.

Do not preserve a pattern merely because it already exists. Do not lift it merely because names look
similar. Shared machinery is permitted only where meaning and lifecycle are identical.

## Step 6: Plan where new code will live

For every new file, type, method, or constant, state location and justification:

| New code | Location | Justification |
|----------|----------|---------------|
| (type/method/const) | (exact path) | (why here and not elsewhere) |

Apply placement rules:
- HTTP routes only in controllers with attribute routing
- Core logic in `src/` feature folders, not in controllers
- Options in `*Options` types near the feature or hosting config
- Constants centralized in a project-scoped `Constants` class
- One public/top-level class per file
- If the project exceeds four classes, keep sources in folders (only `.csproj` at root)

## Step 7: Check for potential violations

Before proceeding, confirm:

- [ ] No inline endpoints (`MapGet`/`MapPost` etc); all routes are controllers
- [ ] If inline endpoints are observed in the area, note the exception and cite the ADR or existing pattern
- [ ] No empty placeholder classes or commented-out scaffolds
- [ ] No magic literals; constants are centralized and typed options are used
- [ ] First-class model statics are used for data access when available
- [ ] Large data access uses a capability-qualified stream (`AllStream`, `QueryStream`) or explicit paging; InMemory/JSON/Redis do not currently stream
- [ ] Docs/ADRs/TOCs will be updated when behavior or policy changes

## Step 8: Present the plan

Summarize findings in this exact format:

**Task:** (one sentence)
**Application intent:** (the user's business sentence)
**Public expression:** (smallest honest C# plus the complete references/decorations/config/context/runtime surface)
**Guarantee/correction:** (what becomes guaranteed and the safe corrective failure)
**Complete intent surface:** (all required user actions; explicitly say when none exist beyond the expression)
**Public concepts:** (each visible concept mapped to its business decision or guarantee)
**Docs read:** (list with one-sentence relevance notes)
**Code read:** (list with one-sentence relevance notes)
**Reusing:** (list what already exists)
**Creating new:** (table from Step 6)
**Coalescence:** (closest pattern, specificity, keep/absorb/rebuild/delete, one target owner, deletions)
**Ergonomics:** (human readability, IntelliSense discovery, coding-model legibility, cognitive branches)
**Constraints satisfied:** (bullet list of the global constraints above, mark any exception)
**Risks:** (anything you're unsure about)

The active work card or ADR must contain the application intent, complete expression, guarantee,
coalescence decision, and ergonomics evidence before production edits. Then stop and wait for approval
before implementing unless the user has already granted explicit standing authorization for this scope.
Pliki w paczce (2)
  • SKILL.md 8 KB
  • agents/openai.yaml 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · sylin-org/koan-framework100Apache-2.0
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
rapiddweller/archkeel100MIT
zimoliao/scholaraio100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT

Migawka bazy z 13.11.2026 · wersja paczki ed232cbd0387 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90koan-explain
    Wyjaśnia, jak działa aplikacja Koan na podstawie lokalnych danych, nie zmieniając przy tym plików.
  • 100koan-upgrade
    Audytuje, planuje i migruje starszą aplikację Koan do bieżącej wersji, zachowując obserwowalne kontrakty i zatrzymując się, gdy nie da się wykazać zamiennika.
  • 100exploration-strategy
    Prowadzi eksplorację bazy kodu: wyszukiwanie wzorców, zbieranie kontekstu i zrozumienie struktury kodu przed planowaniem lub implementacją.
  • 95codebase-explore
    Analizuje bazę kodu wyłącznie do odczytu: sprawdza architekturę, szuka powiązanych plików i poznaje projekt przed zmianami.
  • 90explore-codebase
    Zbiera kontekst z kodu przed planowaniem: pliki, wzorce, projekty Nx, kod do ponownego użycia, ograniczenia i otwarte pytania.
  • 100explore-before-editing
    Buduje mapę nieznanego kodu przed zmianą: punkty wejścia, warstwy, konwencje, polecenia budowania i testów oraz to, co może pęknąć.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.