mentor
/mentor
Prowadzi użytkownika jako mentor przez program własnego rozwoju zawodowego, oparty na oczekiwaniach organizacji, ustaleniach i ludziach, od których można się uczyć, z zapisem w pamięci osobistej.
- Autor
- ibrain-bvba ↗
- Repozytorium
- gutt-claude-code-plugin ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 14.09.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 14.09.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Prowadzi użytkownika jako mentor przez program własnego rozwoju zawodowego, oparty na oczekiwaniach organizacji, ustaleniach i ludziach, od których można się uczyć, z zapisem w pamięci osobistej.
Wyzwalacze z opisu
Argumenty
/mentor <growth goal or mentoring context>
Oryginalny opis (EN)
Guide goal-shaped professional growth with no new territory to map — the AI is the mentor, the user is the mentee, and the outcome is the person's own development program, grounded in organizational expectations, agreements, lessons, and people to learn from, then tracked in personal memory. Use when someone wants to improve a practice, grow toward a role, prepare for a responsibility, or prepare to mentor someone else. Joining a team is onboarding-guide's job; logging an existing program is progress-tracking's.
Jak działa
- Scope and privacy
- What goes where
- Trigger
- Workflow
- Failure modes
- Grounding Protocol
- Output Format
- Example Invocation
Podgląd SKILL.md
---
name: mentor
description: "Guide goal-shaped professional growth with no new territory to map — the AI is the mentor, the user is the mentee, and the outcome is the person's own development program, grounded in organizational expectations, agreements, lessons, and people to learn from, then tracked in personal memory. Use when someone wants to improve a practice, grow toward a role, prepare for a responsibility, or prepare to mentor someone else. Joining a team is onboarding-guide's job; logging an existing program is progress-tracking's."
argument-hint: "<growth goal or mentoring context>"
model: sonnet
---
# Mentor
The mentee states a goal; the mentor grounds it in what the organization already
knows, adds what general practice says, and turns both into a program the person
owns — stored in their personal scope so a later session picks it up without
them re-explaining anything.
Invoke `gutt-pro:memory-search` for org grounding,
`gutt-mentor:individual-program-design` to create the confirmed personal
program, and `gutt-mentor:progress-tracking` to resume or update it. Skills do
not support the agent frontmatter `skills:` preload, so refer to these skills
explicitly when their part of the workflow begins.
**This is self-service: the AI is the mentor, and it serves whoever is running
it, for themselves.** Personal scope is derived from the authenticated login, so
running it "for" someone else would file their program under your name. A human
mentor preparing to mentor another person is a different mode — see Step 6.
**It is conversational where it writes.** Steps 2 and 5 elicit goals and confirm
the write with the person, so when they are not present to answer — a background
run or another unattended invocation — stop after Step 4: return the assessment and a
draft program, and write nothing. A re-invocation carrying the confirmed draft
picks up at Step 5 rather than re-grounding.
## Scope and privacy
This workflow writes only to the person's personal scope — **never to the org
graph**. What someone is working on growing, and where their gaps are, is theirs;
sharing any of it is not this workflow's call to make. Per the identity convention,
a workflow that never writes org-side registers nothing, tags nothing, and runs no
identity-scoped recall — so there is no `register_agent` call and no `agent_id` on
any read or write, personal ones included. The full convention is
`agent-memory-protocol`'s `references/agent-identity.md`; on any conflict it
wins. That skill is deliberately not invoked here — this workflow has nothing to
register or tag — so locate that file and read it if you need more than this
paragraph.
## What goes where
> **Everything this workflow writes is personal. It reads the org graph; it never
> writes to it.**
| | Where |
| ------------------------------------------------------- | ---------------------------------- |
| Growth goals, program, milestones, cadence | Personal only |
| Check-ins, statuses, gaps, blockers | Personal only |
| Expectations, agreements, lessons, examples of practice | Read from org — never written back |
| The assessment itself | Output to the person; not stored |
## Trigger
- "I want to get better at \<practice>" — code reviews, incident handling,
estimation, writing
- "How do I grow toward \<role>?" — senior engineer, tech lead, architect
- "I want to prepare to lead a project / team / initiative"
- A returning check-in on a growth program already in progress (Step 1 catches
this)
Not for joining a team, rotating onto an engagement, or ramping into an
unfamiliar system — that is ramp-shaped work with territory to map, and it
belongs to `onboarding-guide`. Not for logging progress against an existing
program on its own — that is `progress-tracking` directly.
## Workflow
**First: whose growth is this?** The person running it, for themselves →
Steps 1–5. A human mentor preparing to mentor someone else → Step 6, which runs
Steps 2–4 and skips Step 1: the resume check below reads the _invoker's_
personal scope, so on a run about someone else it would find the invoker's own
program and misroute.
### Step 1: Resume before you start
Anything already on record beats anything you would ask for. Run
`progress-tracking`'s thread read first: `get_episodes(group_id="personal",
last_n=25)`, matching episode **names** — the program is `Development program —
<slug>`, its check-ins `Program check-in <date> — <slug>`. Widen once if
`has_more` comes back `true`. That skill owns the rest, including why searching
for the slug cannot find a program. Let this read return before any other call —
its result decides whether anything else runs at all.
A person can hold several programs at once — an onboarding ramp and a growth
program, or two growth programs — so the slug names the focus, and finding _a_
program is not finding _this_ one. Found one? **Check it is the same goal before
resuming** — the record's goals and focus against what the person is saying now.
A match is a returning session: report status from the record and hand off to
`progress-tracking` — do not re-ground a goal they already have a program for. A
program for a plainly different goal is not a resume: say what you found, leave
it untouched, and continue to Step 2 under a different `<slug>` — replacing a
program is `individual-program-design`'s business, on the person's say-so only.
Nothing there at all? Continue to Step 2.
**Neither clearly is its own case, and the common one:** a near-match, several
candidates, or a record whose provenance you doubt. Do not force it into either
branch — say what you found and ask which it is. With nobody to ask, treat it as
not a resume, say why you did not use it, and continue to Step 2.
### Step 2: Elicit the goal
This is the step the whole run turns on, and it is a conversation, not a form —
though with the person present it may open with one: offer one optional
multi-choice question up front — likely focus areas, what they care about most —
once, as a shortcut, never a gate. Declined, ignored, or answered, the
conversation below still shapes the goal; an unattended run gets no question of
any kind (the contract above). Get, in the person's own words:
- **The goal itself** — two or three beat eight (`individual-program-design`'s
rule).
- **Why now** — what prompted it: feedback received, a role opening, a struggle.
- **What _done_ looks like** — an observable outcome, not a feeling.
- **Where they are now** — their own read on their current level and what they
have already tried. This shapes the milestones; it never enters an org query.
- **The constraint** — time available, a deadline, a review cycle.
Never infer a goal to keep moving — a guessed goal produces a program about the
wrong thing. Nothing stated and nobody to ask → return the questions above plus
what Step 3 finds on whatever the request does name, as a draft.
The goal decides what Step 3 searches: its **domain** — the practice involved
("code review", "incident response") — and its **target**, when it names one
(a role, a responsibility). No role or system is required here; that is
onboarding's shape, not this one.
### Step 3: Ground in what the org has recorded
Open with **one unscoped discovery read** —
`search_memory_nodes(query="<the goal's domain>")`, no `group_ids` — solely to
learn the group names: every node and fact a read returns carries its own
`group_id`, personal hits labelled `personal`. Take the org group names from
that **`group_id` field** — never off a node's readable id prefix, which is an
alias that need not match the group it belongs to, never off a write tool's name
suffix, and never guessed. If it surfaces no org group and nobody can name one,
skip the org reads and say so — see Failure modes.
**More than one org group is a question, not a list.** A graph can hold a
sandbox or fixture group that looks exactly like an org group and reads as fact,
so say which ones you found and ask which is authoritative. With nobody to ask,
read them all, but a record — or a whole group — that declares itself test,
sandbox, or fabricated content is **not evidence**: leave it out and say what
you left out. Attribute every claim you do use to the group it came from.
Every call below is an **org read**. `<org>` stands for the org group names the
discovery read returned — pass them on every call, because omitting `group_ids`
leaves the person's personal scope in the default search scope, on the fact
searches just as much as the node searches. **Query the topic, never the person
and never their sentence:** the person's name and their self-assessment never
appear in a query string, and the literal ask ("I want to get better at…")
matches first-person noise, not guidance — decompose it into topic queries like
the rows below.
Run every row; a pure practice goal has no separate target, so its expectations
row folds into the agreements row rather than running twice. Work the middle
column, judge what came back, and reach into the right column only where the
first pass left the question open — a rung-2 call needs a node id the first
pass returned, which is why it cannot come first. Every row's first pass ends
with an **uncentered** fact search, because `memory-search`'s first rule runs
nodes and facts together — a fact often carries the answer and outranks the
entity summary.
| What the org may hold | Rung 1 — first pass | Rung 2 — only if that left a gap |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| Expectations and recorded paths | `search_memory_nodes(query="<target> expectations responsibilities", group_ids=[<org>])` | `search_memory_facts(query="expected of <target>", center_node_id="<role or team node id>", group_ids=[<org>])` |
| for the target | `search_memory_nodes(query="<target> career path development program curriculum", entity="Document", group_ids=[<org>])` | |
| | `search_memory_facts(query="<target> expectations growth", group_ids=[<org>])` | |
| Working agreements and culture | `search_memory_nodes(query="<domain> working agreement standard process", entity="WorkingAgreement", group_ids=[<org>])` | — |
| in the domain | `search_memory_facts(query="<domain> agreement practice", group_ids=[<org>])` | |
| Lessons in the domain | `fetch_lessons_learned(query="<domain>", group_ids=[<org>])` | — |
| | `fetch_lessons_learned(query="<domain> pitfall mistake", group_ids=[<org>])` | |
| People to learn from | `search_memory_nodes(query="<domain> experience mentoring", entity="Person", group_ids=[<org>])` | `search_memory_facts(query="how they practice <domain>", center_node_id="<person node id>", group_ids=[<org>])` |
| | `search_memory_facts(query="<domain> expertise example", group_ids=[<org>])` | |
| Prior programs for similar goals | `search_memory_nodes(query="development plan <domain or target>", group_ids=[<org>])` | — |
| | `search_memory_facts(query="development program plan <domain or target>", group_ids=[<org>])` | |
Each cell is one pass in `memory-search`'s sense: best phrasing first, judge,
reformulate at most twice, `max_nodes≈10`. Go specific before broad and stop a
row once results repeat. An entity-filtered search that comes back empty is
usually a schema mismatch, not an absence: retry once without the `entity`
filter, or check `get_available_schemas` — the labels above are a convenience,
the graph is authoritative. `fetch_lessons_learned` opening its row is the one
exception `memory-search` allows itself — a growth goal is explicitly about
lessons and pitfalls.
**A node's name is not evidence.** Extraction can attach unrelated content to a
promising name — a node called "promotion process" can hold notes about
something else entirely. Read the summary before citing, and cite only what the
body actually supports.
And check a centered call actually honored its center: a result set that never
mentions the center node means the parameter was ignored — discard it and treat
the gap as still open, rather than quoting facts that are about something else.
**Rung 2 is the ceiling.** Centered fact searches return current facts only, so
they cannot hand the person a superseded relationship; the `graph-traversal`
tools can, without warning, and they can fail outright on a hub — which is
exactly what a person or team node is. Hand a genuine multi-hop question to the
`gutt-pro:gutt-pro-memory` agent instead of traversing inside this run.
Apply `memory-search`'s relevance gate ruthlessly. A weak hit dressed up as org
guidance is worse than saying the org has nothing recorded here — the person
cannot tell the difference and will act on it.
### Step 4: The mentor's assessment
Deliver three layers, each labeled as what it is, per Output Format:
1. **What your organization has** — expectations, agreements, lessons, people,
prior programs. Cited by readable id, attributed to its group.
2. **What it doesn't** — said directly: "your organization has no recorded
career ladder", "few lessons touch incident response". A thin graph is a
finding, not a failure; never pad it with weak hits.
3. **General guidance** — what general practice says about this goal, explicitly
labeled as general knowledge, not as something the org recorded. Lead with it
where the org layer is thin.
Assemble the **materials list** here, each entry marked by provenance: found in
the org graph (with id), general practice, or named by the person. Prior
programs found in Step 3 are **history, not a template** — read them all, then
build for the person in front of you.
This is output to the person. It is not written to memory.
### Step 5: Build and store the program
Hand to `individual-program-design` — it owns the program record, the cadence
and the status vocabulary, and its rules apply unchanged: goals in the person's
own words, never inferred; the write is `add_personal_memory`, no `agent_id`,
`last_n_episodes=0`; confirm before writing; verify once, never write twice.
**Use that skill's headings verbatim, and add none.** `progress-tracking`
reconstructs status by reading them, and a renamed or added heading reads as a
missing section. Materials therefore live inside the fixed shapes: a material
the program uses becomes its own milestone row — one condition, worked through
it or not — and a goal line may cite the org source it grounds on. There is no
`## Materials` heading.
Pick a `<slug>` that names the growth focus (`code-review-craft`,
`toward-tech-lead`) and does not collide with any program Step 1 found — an
onboarding ramp and a growth program routinely coexist.
Give the skill the grounding from Steps 3–4 so milestones attach to real
agreements, real people, and real materials rather than generic ones. A
milestone still only ever marks progress toward a goal the person actually
stated.
When the person is not present to confirm (the contract in the opening): return
the assessment and the filled skeleton marked **draft** — goal lines blank or
marked proposed rather than invented — and write nothing.
### Step 6: Preparing to mentor someone else
A human mentor getting ready to mentor another person runs Steps 2–4 only, with
the mentor answering Step 2 for the relationship — the goal they intend to work
on together. Nothing is written on this path, anywhere: a personal write would
file under the invoker's own login, not the mentee's, and this workflow never
writes to the org graph regardless.
Keep the mentee out of the queries: org reads are about the goal's domain, and
the mentee's name adds nothing to "what are our review practices". Deliver the
assessment and stop. Say in one line that the mentee can run this skill
themselves to get a program of their own — that is the only path that files it
correctly.
## Failure modes
Never fail the mentoring because memory is degraded, and never guess a group
name.
| Observable | Response |
| ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Memory server absent | Mentor from general knowledge, labeled general and ungrounded; put the program skeleton in the reply so nothing is lost, and store it in a later session |
| Discovery read returns only `personal` | No org group to read: say so in one line and assess from the general layer, labeled. The personal program still stores — it needs no org group |
| An entity-filtered search comes back empty | Schema mismatch until proven otherwise — retry unfiltered (Step 3) |
| The graph is thin on this goal | Not a failure: say it plainly, lead with the general layer, and keep the two labeled apart (Step 4) |
| A centered result never mentions its center | The parameter was ignored — discard the result set and treat the gap as still open |
| `add_personal_memory` hidden or denied | The skills own this: the filled skeleton goes in the reply, retry in a later session, and never substitute an org write |
## Grounding Protocol
The passes live in the workflow — **Step 1** (personal, always first: its result
decides the run's mode) and **Step 3** (org, group-wide). There is no
identity-scoped pass, because nothing registers (Scope and privacy).
**Minimum outcome before you assess:** whether a program already exists for this
goal, and what the org actually holds on it. If memory was unavailable, say so
in one line rather than presenting a general assessment as a grounded one.
Take each anchor from a read — never hand-build an id:
| Anchor | From | What it anchors |
| ----------------------------- | ----------------------- | ----------------------------------------- |
| the org group name(s) | Step 3's discovery read | every org `group_ids` |
| role / team / person node ids | Step 3's node searches | `center_node_id` on rung-2 fact searches |
| program `<slug>` + newest id | Step 1's episode read | resume, and `progress-tracking`'s handoff |
## Output Format
Cite a node by its readable `id` (`alias:Label:slug`) — that is what the person
can carry into a follow-up question. Only facts and episodes are raw UUIDs.
However the assessment is rendered — including any shortened or restated
version of it — the three layers keep their labels: a general-practice item
under an org heading tells the person their organization recorded something it
did not.
```markdown
# Growth assessment: [the goal, in their words]
## Starting point
[What they told you — goal, why now, current level, constraint — played back]
## What your organization has
- [Expectation / agreement / lesson] (id: xxx, group: yyy)
### People to learn from
| Person | Why | ID |
| ------ | --- | --- |
## What it doesn't
[The gaps, stated plainly — "no recorded career ladder", "no lessons on X"]
## General guidance
[Best practice from general knowledge — labeled as general, not org-recorded]
## Materials
- [Material] — org (id: xxx) / general / yours
## Your program
[Goals, milestones and cadence as confirmed, and where it was stored]
```
The last section changes with the path. Stored program → goals, milestones,
cadence as confirmed, and that it was stored in personal scope. Nobody present →
the same shape marked a **draft**, goal lines blank or marked proposed rather
than invented, and a line saying nothing was stored. Step 6 → drop the section
and close with that step's one-line pointer instead.
On a returning session, replace everything above with `progress-tracking`'s
status summary — goals, milestones done versus open, next actions, last
check-in date — and say what changed since. Do not re-assess a goal that
already has a program.
## Example Invocation
```
/gutt-mentor:mentor I want to get better at code reviews — help me figure out
what to work on and set up a program I can track.
```
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · ibrain-bvba/gutt-claude-code-plugin | 100 | MIT |
| mcouthon/agents | 100 | MIT |
| rikdc/claude_code_template | 100 | MPL-2.0 |
| Shreyaan/skills | 100 | MIT |
| MaiBP/professional-twin | 100 | MIT |
| 7ekmaz/senior-mentor | 100 | MIT |
| ayhammouda/mentor | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 417ef3fd6625 (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
- 100mentorship-program
Prowadzi rejestr mentoringu: para mentor i mentee, dział, obszar, cel mentee, liczba sesji, ostatnia i następna sesja, ocena ogólna, notatki o postępach i status. - 100mentorship-program
Prowadzi rejestr mentoringu: para mentor i mentee, dział, obszar, cel mentee, liczba sesji, ostatnia i następna sesja, ocena ogólna, notatki o postępach i status. - 100individual-program-design
Zapisuje program rozwojowy osoby, z celami, kamieniami milowymi i rytmem check-inów, jako samodzielny epizod w osobistej pamięci, który późniejsza sesja może podjąć od zera. - 100onboarding-program
Pomaga kształtować wdrożenie pracowników: czas do produktywności, program dla każdej roli, parowanie z mentorem i kamienie milowe 30, 60 i 90 dni. - 100mentorship-onboarding
Organizuje start relacji mentor-mentee według programu Entering Mentoring (CIMER), ustalając oczekiwania, rytm komunikacji i zasady informacji zwrotnej. - 100personal-growth-mentor
Pełni rolę mentora rozwoju osobistego: pomaga ustalić cele, zaprojektować nawyki, podjąć decyzje strategiczne i utrzymać rozliczalność, bez motywacyjnej waty.