Project Management logo

Project Management

Organization
vanillagreencom
project-management

Load to plan a cycle, audit issues, build a roadmap, or decompose research into issues.

Overview

Publishervanillagreencom
Repositorykendex
Skill nameproject-management
Stars
80
Forks
31
Bundled files
22
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 22 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by vanillagreencom on GitHub. Read the source before you install it.

Installation

Install the Project Management AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/vanillagreencom/kendex.git /tmp/kendex
mkdir -p .claude/skills
cp -r /tmp/kendex/skills/project-management .claude/skills/project-management
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Project Management in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Project Management on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Project Management is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Project Management

Wrappers run in the primary session: they own the user dialog and every tracker mutation. TPM workflows analyze and return JSON inline; they never mutate the tracker. The fleet proposal sweep runs in a TPM lane and writes its analyzed JSON for the overseer.

Disposition

  • Creation bar. File an issue only when all three hold:

    • it changes what a user or operator experiences, or blocks work that does;
    • no open issue, active branch, or one-line fix already covers it;
    • someone could pick it up and finish it without a new investigation.

    A reproducible anomaly with evidence in hand passes all three as an investigation issue. Everything else is declined with one line in the report: no issue, no placeholder, no tracking artifact. Failing the bar: a severe-sounding edge case no real input reaches, a hypothetical of low severity, a coverage ask for a path that has not regressed, a refactor that neither changes behavior nor unblocks user-visible work, and the classes in ../orch/references/finding-disposition.md § Decision flow Step 0, whatever source the candidate arrived from. Two exceptions file at any likelihood: a security or data-loss defect a shipped path reaches, and an edge case whose failure is critical harm or financial loss.

  • Name what reaches it. Every issue carries a Reached by: line giving the user action, run, check, or shipped producer that arrives at the defect; an owner-directed item names the ask.

    • The thread a finding came from, a shape ("a name containing a quote"), or something true in theory is not a reach, and an item with nothing to name is a decline, not an issue. The judgement is the author's: issues create under LINEAR_REQUIRE_REACH refuses only a body with no Reached by: line, an unsubstituted placeholder and a null token (TBD, n/a, none, -) counting as absent.
    • A filing whose source is a review round carries, at priority 2, a Symptom: line naming the run, the user, or the red check that already showed the defect (--review-born). Priority 2 from any other source is structural, reports no symptom, and is not checked for one. Where a review-born finding files at all is ../orch/references/finding-disposition.md § Filing bar.
  • Burn down more than you create. Every audit that reads an issue backlog sweeps its comparison set for issues the codebase has already satisfied, duplicated, or superseded, and proposes those for cancellation in the same pass, along with every active issue that fails the creation bar as it stands today. Report created N / closed M. project-order reorders projects, reads no backlog, and does not sweep.

  • Ask about work, never about mechanics. Creation and cancellation follow audit-issues § 6; the user decides activation. Labels, priorities, relations, hierarchy, sort order, and project moves are corrections the workflow applies on its own authority.

  • Research is part of planning, not a work item. Gather prior art, vendor docs, and approach comparisons inline during planning. Store the artifacts in the tracker under § Planning artifacts. A tracker research issue exists only when the research is delegated as standalone work: run by the researcher agent, or prepared for later pickup (research-spike).

  • One approval per decision. Ask the user to approve a body of work once, at the roadmap plan gate. Creation re-asks only what changed after that answer.

Planning artifacts

Planning, research, roadmap, and audit files under docs/ are tracked repository content. Temporary review output belongs under tmp/reviews/. Attach each produced artifact and each cited planning input to the Linear issues the wrapper creates or updates. After the planned mutations for an issue, run issues update [ISSUE_ID] --attach [PATH], repeated per file, as an attach-only call. Include companion files needed to read the artifact, such as roadmap JSON and research metadata. Keep its returned attachments[] entries and add an **Artifacts** list to the issue description: one [repository-relative path](url) link per entry. Replace the prior link for the same path and preserve links to other inputs. Those links identify the published version even when older attachments share the path. Verify every attachment and description write before reporting completion. A run with no issue writes keeps its files locally until creation; it creates no issue only to hold files.

Keep repository-relative references in the brief. Linear attachments are the fallback when a fresh clone lacks a cited file. Resolve it through linear SKILL.md § Resolve a cited artifact.

Carry each planning artifact's repository reference, readable path, and source issue separately. A same-checkout delegation receives the readable path for analysis and the reference for its output. A handoff to another checkout carries the reference and the issue that holds the attachment; the receiver resolves its own readable path through the Linear rule above. Saved plans and tracker text contain references and source issues, never cache paths. A source issue identifies storage, not the roadmap's hierarchy origin. With no published source issue, keep the existing local-until-creation flow.

For a GitHub audit, put the produced text artifact in the created or updated issue body, and include the text of any cited planning input needed for pickup. Report binary inputs that have no tracker upload route as incomplete; never claim a local-only file is available to another lane. A run without artifacts retains its existing tracker behavior.

Commands

CommandArgumentsWorkflow
cycle-plannonecycle-plan
audit-issuesproject | project "Name" | team | issue [IDs] | --issues [file] | --analyzed [file] | project-orderaudit-issues
roadmap plan[feature] | [feature] @[research-or-plan-path]roadmap-plan
roadmap create@[plan-file]roadmap-create
research-spikenoneresearch-spike
research-complete[ISSUE_ID]research-complete
research-issuenoneresearch-issue, internal, invoked by research-spike
proposal-sweepfleet briefproposal-sweep, internal, invoked by oversee

audit-issues is primary-session only (audit-issues preamble): the roadmap-plan § 5 answer that roadmap-create carries in is validated and admitted at § 6, never around it.

The @[path] given to roadmap plan may be research findings or a finished plan (a design the user has reviewed). A finished plan is the spec: derive issues from it instead of re-planning, and every issue cites it.

TPM analysis workflows, each returning JSON per its schema: tpm-cycle-plan, tpm-audit (project / team / issue / project-order modes), tpm-roadmap-plan.

Execution Rules

  • Run workflow sections in order. Skip only on an explicit Skip if condition, never on your own scope assessment.
  • <delegation_format> and <output_format> are literal templates: fill [PLACEHOLDERS], drop lines whose placeholders are empty, add nothing.
  • Send a user-visible <output_format> report as a normal assistant message first, then invoke the question tool separately with only the question and short option labels. Never paste the report into question text or options.
  • The Linear cache holds the whole workspace: sync sends no team filter, and cache issues list returns no team through its safe, compact, ids or table formatter, so a row read through those cannot be checked against --team X (only --format=raw carries .team.name). Team scope per path: § Scope by Path.
  • Sync the Linear cache before a workflow's first cache read: sync --reconcile in a run that mutates the tracker, sync --if-stale 15 in a read-only lookup. That sync is the freshness mechanism; a cached read itself enforces presence, so a read that comes back missing halts the workflow and reports the sync failure, never a partial result, a live-only substitute, or a retry against the unsynced cache.
  • Resolve tracker context once per run (audit-issues § 1.2) and route every preflight, fetch, and mutation through it. A GitHub-tracked run must not require Linear installation, sync, or authentication; where GitHub lacks a Linear concept, degrade in a documented note, never silently.
  • Before any issue create or label update, run the label preflight in references/labels.md against the live inventory and project taxonomy; any § Validation failure there halts before mutation.
  • A project declares its taxonomy in one of the sources references/labels.md names: inline in its kendex manifest under [skill-instructions] for this skill (kendex.toml, or kendex-local.toml in a source-catalog checkout), which renders it into § Project Instructions above, or in a project document or reference file those instructions link to. A project that declares none in any of them has no required categories to enforce.
  • In multi-issue analysis, keep verification context per issue. One issue's PR, branch, or resolved path set never scopes another's checks.

Scope by Path

The Linear cache is workspace-wide, so each path states whether it resolves the team scope (tpm-audit § 1.1.1) and what it filters. Silence is not inheritance: a new mode adds its row.

PathResolvesFilters
tpm-audit project, teamyes§ 1.3 projects, § 1.4 input set, § 1.5 comparison set
tpm-audit issues, Linearyes§ 1.5 comparison set; a § 1.4 input issue outside scope halts
tpm-audit issues, GitHubn/a, reads no Linear cachen/a
tpm-audit project-orderyes§ 11 initiatives, projects, and per-project issues
tpm-roadmap-planyes, § 1.1§ 1.4 projects, § 1.5 comparison set
tpm-cycle-plannono. session-status picks the active project workspace-wide, and every later read is scoped to that pick
audit-issues §§ 7.2-7.5n/a, executes an artifact tpm-audit produced under its scopereads rooted at an in-scope project or an issue this run mutated
audit-issues § 1.2.1, § 3nono. session-status selects projects workspace-wide
cycle-plan, roadmap-plan, roadmap-create, research-spikenono. Project, initiative, and label reads span the workspace
research-completen/areads are rooted at the caller's issue identifier
research-issuen/areads rooted at the caller's identifiers; the project it creates into is the caller's pick

Hierarchy

Initiative → Project → Milestone → Issue → Sub-Issue. Parent and child must share a project; blocking relations may cross projects freely. See references/dependencies.md.

Contracts

KindFiles
Schemasaudit-issues-input, audit-output, roadmap-plan-input, roadmap-plan-output, cycle-plan-output
Templatesissue-description-template, parent-issue-template
Referenceslabels, dependencies
Tracker CLILinear: .agents/skills/linear/scripts/linear.sh; GitHub: gh + .agents/skills/github/scripts/github.sh

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Project Management AI skill do?

Load to plan a cycle, audit issues, build a roadmap, or decompose research into issues.

Why use Project Management on TypingMind?

Because you install it once and use it with any model. Project Management is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Project Management in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/vanillagreencom/kendex/tree/main/skills/project-management. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Project Management?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Project Management?

As many as you like. As long as a model supports skills, you can use Project Management with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Project Management AI skill free?

Yes. It is published on GitHub by vanillagreencom under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇