View Transitions
thedaviddias/Front-End-Checklist
A skill your agent uses when adding page transition animations, image expand/contract effects, shared-element transitions, or improving navigation UX in a single-page or multi-page application.
Helps engineering managers navigate role transitions — produces a four-type framework for first management roles (Apprentice, Successor, Pioneer, New Boss), an acquisition integration model…
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install manager-dot-dev/manager-skills management-transitions --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/management-transitions .claude/skills/management-transitions && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .claude/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitionsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install manager-dot-dev/manager-skills management-transitions --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/management-transitions .agents/skills/management-transitions && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .agents/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install manager-dot-dev/manager-skills management-transitions --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/management-transitions .cursor/skills/management-transitions && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .cursor/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/manager-dot-dev/manager-skills.git --path skills/management-transitions--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install manager-dot-dev/manager-skills management-transitions --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/management-transitions .gemini/skills/management-transitions && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .gemini/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install manager-dot-dev/manager-skills management-transitionsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/management-transitions .github/skills/management-transitions && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .github/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add manager-dot-dev/manager-skills --skill management-transitions -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install manager-dot-dev/manager-skills management-transitions --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/manager-dot-dev/manager-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/management-transitions .opencode/skills/management-transitions && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "management-transitions" agent skill from https://github.com/manager-dot-dev/manager-skills/tree/main/skills/management-transitions into .opencode/skills/management-transitions/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "management-transitions", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
management-transitionsHelps engineering managers navigate role transitions — produces a four-type framework for first management roles (Apprentice, Successor, Pioneer, New Boss), an acquisition integration model…
Management Transitions is an agent skill from manager-dot-dev/manager-skills. Helps engineering managers navigate role transitions — produces a four-type framework for first management roles (Apprentice, Successor, Pioneer, New Boss), an acquisition integration model, guidance for counseling engineers on the management track, a Blue Tape List method for new roles, a broken team turnaround process, and the Dopamine Shift framing for new managers. Use when the user says "new manager," "first management role," "took over a team," "managing former peers," "new team," "just became a manager,"…
Its SKILL.md is about 4.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/extended.md` and `references/sources.md`).
The repository describes itself as: Skills for engineering managers. The licence is MIT.
4 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit c47ebc7. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Management Transitions loads about 4.2k tokens when it runs, and up to ~5.2k if it reads all its reference files. Until then it costs about 171 tokens; SKILL.md has 2,499 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from manager-dot-dev/manager-skills at commit c47ebc7, republished under its MIT licence (© manager-dot-dev). 2,499 words, ~4,247 tokens.
.claude/skills/management-transitions/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.Check for EM context first. If .agents/em-context.md exists, read it.
If .agents/em-context.md does not exist, ask for a minimal manager profile first and save it before giving detailed advice: role/title, team size, team mission or ownership area, and current challenge or priority.
If a specific person is central to the conversation and .agents/reports/[name].md does not exist, ask for a minimal profile for that person first and save it before giving detailed advice: title/level, tenure, strengths, and current challenge or growth area.
.agents/em-context.md or .agents/reports/[name].md automatically. Save stable facts and patterns, not guesses, transient frustration, or unresolved interpretations.Keep the first answer concise and useful. Do not dump the whole framework unless the user asks for depth.
Default to:
references/extended.md — Second-Time Manager Mistakesreferences/extended.md — The EM Role in the New EraWhen helping with a management transition, orient the manager before giving advice:
For inherited teams, separate learning the system from fixing the system. Premature certainty is the main risk.
From The Making of a Manager by Julie Zhuo. Every first-time manager falls into one of these four paths — each with its own specific challenges.
You were promoted from within the team. Your manager moved on, and you stepped up.
Unique challenge: former peers. The power dynamic shifted, and everyone knows it. Some team members may feel they deserved the role. Resentment can go unspoken for months.
What to do: Talk about it directly. Acknowledge the awkwardness in a 1:1. It defuses more than you expect.
Unique challenge: balancing coding and managing. You're still expected to contribute technically, and it's tempting to stay mostly an individual contributor.
What to do: Start at 60–70% IC work if needed, but consciously step that down over time. Your value as a manager grows as you free up headspace from execution.
You came from outside the team to replace a previous manager.
Unique challenge: no smooth transition. The previous manager is gone. No handoff. You're learning everything cold — team dynamics, technical debt, in-flight projects, unresolved conflicts — while people are watching to see who you are.
Unique challenge: the predecessor's shadow. If the previous manager was well-liked, you'll be compared unfavorably to things they did. If they were poorly liked, people will project those behaviors onto you.
What to do: Change slowly. Listen before acting. Earn trust before changing things. Resist the urge to immediately "fix" what you think is wrong — most of that assessment will be wrong in the first 60 days.
You're starting a new team from scratch. There's no team yet — just you and a mandate.
Unique challenge: you're alone. No peers on your team, no existing culture to lean on, no playbook. Everything is being invented.
Unique challenge: early hiring decisions define everything. The first few people you hire set the tone for culture, technical standards, and working norms. There's enormous pressure to fill seats fast.
What to do: Don't hire out of desperation. A bad early hire is much harder to fix than a slower start. Be patient and hold the bar.
You joined from outside the company to manage an existing team.
Unique challenge: blank page advantage — and the pressure to use it wrong. You have fresh eyes and no baggage. The temptation is to immediately share all your opinions on what's wrong and how things should be done differently.
What to do: Listen first. Don't push your opinions in the first weeks. Ask questions, understand context, learn why things are the way they are. You'll be more effective when you've earned trust.
Unique challenge: building relationships from zero. The team doesn't know you. You need to build trust with each person individually before you can lead them as a group.
What to do: Schedule a 30-minute 1:1 with every person on the team in your first two weeks. Treat it as listening, not presenting. Ask about them, their work, what's going well, what's frustrating. These relationships are the foundation everything else is built on.
When your team or company is acquired, the transition combines elements of all four types above — but with a specific failure mode that deserves its own entry.
The most common mistake: moving too fast.
Acquirers often want to show progress quickly — integrating processes, standardizing tools, reporting structures. The acquired team reads this as: "They don't trust how we did things." The result: the exact people the acquirer wanted to retain start leaving.
What to do first: build trust before changing anything.
In the first 60–90 days:
The shared success is key. It creates a reference point that makes future change less threatening: "We did X together. Now let's try changing Y."
Then increase pace — but together.
Once trust exists, the acquired team will pull you toward improvement. Changes they suggest are adopted; changes you impose create resistance. The goal is to become the kind of manager they'd want to build with — not the acquirer who tells them how things should be done now.
When a senior engineer asks whether they should become a manager, three structural headwinds now apply that weren't true in previous years:
The technical pace problem. Stepping back from the IC track carries real skill atrophy risk. The EM role leaves little time to experiment with rapidly evolving tooling, and that gap compounds fast. An engineer who pauses IC growth for three years may find the landscape unrecognizable.
The ladder has flattened. Companies have increased IC-to-manager ratios, meaning Director and VP slots are scarcer and more competitive — especially with experienced leaders displaced from layoffs. A strong engineer can often advance further on the IC track than as a mid-level EM waiting for a Director opening.
The pay assumption is frequently wrong. Staff/Principal IC compensation at other companies often exceeds EM compensation at the current company. The internal promotion looks like a raise but can be a cut relative to the external IC market.
These arguments don't apply to someone who genuinely wants to manage — intrinsic motivation still outweighs the structural math. But they are essential context for an EM helping a report make an informed choice rather than a default one. Present both sides clearly; don't let the engineer assume management is the only path to senior impact.
The second management role is supposed to be easier. Often it isn't — because experience creates overconfidence.
Five common mistakes when coming back to management after a break:
Assuming what worked before will work again. Different organization, different people, different context. You can't copy-paste your methods. Managing junior developers from a previous military-style context is not the same as managing experienced engineers in a product company.
Too eager to change everything. By the time you're promoted the second time, you have years of ideas backed up. The instinct is to immediately fix everything you see. But the previous manager did things that way for reasons you haven't discovered yet — especially in stakeholder relationships.
Making promises you don't follow through on. You arrive motivated, commit to all kinds of improvements, and then get overwhelmed. Three team meetings in the first year instead of the promised monthly cadence. People remember the gap.
Falling into the same old traps. The first time, you can excuse the hard conversations you avoided with "I'm new at this." The second time, the excuses run out — but the avoidance doesn't.
Never stopping to think. A year goes by and nothing you planned actually happened. Build in dedicated reflection time — treat it like a commitment to yourself to review what you planned vs. what you achieved.
Since the end of the zero-interest-rate period (post-2022), the engineering management role has been shifting:
Practical implications for job security and effectiveness:
The most common mistakes new engineering managers make in their first months:
Most of these are instincts from individual contributor work applied in the wrong role.
From The Art of Leadership (Lopp): when you arrive in a new role, everything that feels wrong gets a blue tape label — a note on the wall, a line in a doc, whatever works. You're not acting on it yet. You're just tagging it.
Wait 30 days. Then revisit your list.
Some things will have resolved themselves — they were temporary states you didn't have context for. Some will look different once you understand why they exist. Some will still feel wrong, and now you understand them well enough to actually fix them.
Why this matters: new managers often react to the first wrong thing they see without understanding the ecosystem around it. They fix the visible symptom and break three invisible things. Or they change something that looked like a flaw but was actually a deliberate trade-off.
The blue tape list separates observation from action. It preserves your fresh perspective (which disappears quickly as you normalize) while giving you time to gather context before acting on it.
Practical format: keep a running list of "things that feel off" with the date you noticed them. At the 30-day mark, review it with someone who knows the context. For each item: is this still worth addressing? Do you now understand why it exists? If you were to act, would you act differently than you would have on day one?
The list also becomes useful evidence. If the same issue appears in your notes three times over 30 days, that's different from something you noticed once.
When you inherit a struggling team, the instinct is to blame the previous leader and signal change fast. That almost always backfires.
Don't open with blame. Even if the prior situation was genuinely bad, opening with "the previous approach was wrong" signals disrespect for what people endured to get here. Show that you value their effort before you redirect their direction.
Name the baggage explicitly. Teams don't leave the past behind by hoping it disappears. Name what stops here — specific behaviors, processes, or patterns — and ask the team to help rewrite the rules. The more they co-author the new approach, the more they'll follow it.
Own your part. You may not have caused the problem, but if you were even partially complicit (slow to act, missed signals), say so. Teams forgive mistakes they're told about. They don't forgive the same mistakes being repeated silently.
Reset the target together. Ask the team to look 6–9 months ahead: imagine everything went your way. What do they see? What did you deliver? How do you interact? How do they feel? The shared destination becomes a filter for 100 daily micro-decisions.
Revise the behaviors, not just the goals. Goals without defined behaviors are empty. "Act like owners" means nothing. What specifically does ownership look like on this team, in this context? Be concrete.
The most overlooked transition challenge has nothing to do with skills — it's neurological.
As an IC, your dopamine came from a predictable place: shipping things. Closing a PR. Fixing a bug. Watching something deploy. As a manager, those direct rewards vanish. For weeks or months, you may feel genuinely unfulfilled.
This isn't a sign you made the wrong choice. It's a sign you haven't yet rewired where you get satisfaction from.
The shift: you're not the star anymore — you're the facilitator. You don't ship a project. You help your team ship all projects. The satisfaction comes from different signals: a report growing noticeably, a difficult conversation that landed well, a team delivering something they wouldn't have without you.
Two other common traps for new managers:
If the user asks where a framework came from, wants to read the original article, or wants more context on any topic in this skill — read references/sources.md. For second-time manager mistakes and the EM role in the post-2022 era, read references/extended.md.
1on1s — First-week 1:1s are critical for all four transition typesdelegation — Apprentices especially struggle with letting go of IC workfeedback — Turning around a broken team requires direct, specific feedback conversationsmanaging-yourself — The 10 EM traps hit hardest during transitions© manager-dot-dev, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 2 other files (references) in skills/management-transitions of manager-dot-dev/manager-skills.
Open the folder on GitHubat commit c47ebc7
Management Transitions next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Management Transitions this skillmanager-dot-dev/manager-skills | 114 | — | ~4.2k | Automated safety check: Pass | MIT | |
| View Transitionsthedaviddias/Front-End-Checklist | 74k | — | ~528 | Automated safety check: Pass | MIT | |
| Breadcrumb Navigationthedaviddias/Front-End-Checklist | 74k | — | ~418 | Automated safety check: Pass | MIT | |
| Navigation Landmarkthedaviddias/Front-End-Checklist | 74k | — | ~417 | Automated safety check: Pass | MIT | |
| Keyboard Navigationthedaviddias/Front-End-Checklist | 74k | — | ~567 | Automated safety check: Pass | MIT | |
| Skip Navigationthedaviddias/Front-End-Checklist | 74k | — | ~443 | Automated safety check: Pass | MIT |
thedaviddias/Front-End-Checklist
A skill your agent uses when adding page transition animations, image expand/contract effects, shared-element transitions, or improving navigation UX in a single-page or multi-page application.
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing templates, rendered HTML, or shared components related to Implement accessible breadcrumb navigation.
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing templates, rendered HTML, or shared components related to Use navigation landmark regions.
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing rendered HTML, interactive components, or design-system patterns related to Enable keyboard navigation for all elements.
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing rendered HTML, interactive components, or design-system patterns related to Include a skip navigation link.
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing rendered HTML, interactive components, or design-system patterns related to Use valid ARIA role values.
manager-dot-dev/manager-skills
Score an Engineering Manager's coverage across all 12 cells of the EM Grid based on their calendar and Slack.
manager-dot-dev/manager-skills
Foundation skill for engineering managers. An agent skill from manager-dot-dev/manager-skills.
manager-dot-dev/manager-skills
Prepares agendas, diagnoses struggling 1:1 relationships, and gives frameworks for running effective 1:1 meetings with direct reports.
manager-dot-dev/manager-skills
Explains business financial terms and frameworks for engineering managers — produces term definitions (ARR, COGS, CAC, LTV, gross margin, burn rate, EBITDA, AARRR), translation formulas for making…
manager-dot-dev/manager-skills
Helps engineering managers support direct report growth — produces a stage-by-stage model of engineering impact (Circles of Influence), a framework for non-linear career planning (Tarzan Method)…
manager-dot-dev/manager-skills
Guides managers out of the bottleneck role — provides the Team Rep pattern, Epic Ownership model, Task-Relevant Maturity framework, kingdom ownership, and three-layer assignment strategy.
Helps engineering managers navigate role transitions — produces a four-type framework for first management roles (Apprentice, Successor, Pioneer, New Boss), an acquisition integration model…. Management Transitions is an agent skill from manager-dot-dev/manager-skills. Helps engineering managers navigate role transitions — produces a four-type framework for first management roles (Apprentice, Successor, Pioneer, New Boss), an acquisition integration model, guidance for counseling engineers on the management track, a Blue Tape List method for new roles, a broken team turnaround process, and the Dopamine Shift framing for new managers.
Management Transitions fits situations like: the user says new manager; first management role; took over a team; managing former peers.
Run `npx skills add manager-dot-dev/manager-skills --skill management-transitions -a claude-code`. Or copy the skill folder (skills/management-transitions in manager-dot-dev/manager-skills) into .claude/skills/management-transitions in your project. Claude Code loads it when a task matches its description.
Run `npx skills add manager-dot-dev/manager-skills --skill management-transitions -a codex`. Or copy the skill folder (skills/management-transitions in manager-dot-dev/manager-skills) into .agents/skills/management-transitions in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add manager-dot-dev/manager-skills --skill management-transitions -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/management-transitions, .gemini/skills/management-transitions, .github/skills/management-transitions and .opencode/skills/management-transitions in your project.
SKILL.md names no scripts, command-line tools or credentials: Management Transitions is instructions for the agent only.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Management Transitions is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 4.2k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 970 tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Management Transitions: View Transitions (thedaviddias/Front-End-Checklist, 74k stars), Breadcrumb Navigation (thedaviddias/Front-End-Checklist, 74k stars), Navigation Landmark (thedaviddias/Front-End-Checklist, 74k stars) and Keyboard Navigation (thedaviddias/Front-End-Checklist, 74k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
manager-dot-dev (a GitHub organization) maintains it in manager-dot-dev/manager-skills, which has 114 GitHub stars. The repository holds 27 skills in this directory. The repository was last updated on May 9, 2026.
Source: manager-dot-dev/manager-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.