New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Convex Quickstart

by spokvulcan in spokvulcan/poker-planning

Creates or adds Convex to an app. An agent skill from spokvulcan/poker-planning.

MITAuto-check: notesFrontend & Design

Install Convex Quickstart

skills CLI
$ npx skills add spokvulcan/poker-planning --skill convex-quickstart -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install spokvulcan/poker-planning convex-quickstart --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/spokvulcan/poker-planning.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/convex-quickstart .claude/skills/convex-quickstart && rm -rf skills-src

Use ~/.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/

Facts

Skill name
convex-quickstart
GitHub stars
114
Used in
6 other repos
Token cost
~3.5k tokens
SKILL.md length
1,428 words
Files
3 (incl. assets)
Skills in repo
6
Repo updated
First seen
Licence
MIT

At a glance

Creates or adds Convex to an app. An agent skill from spokvulcan/poker-planning.

  • Works in 6 steps: Determine the starting point: new… → If new project, pick a template and… → If existing app, install convex and wire… → …
  • New Convex projects
  • SKILL.md covers When to Use, When Not to Use, Workflow and Path 1: New Project…, plus 7 more sections
  • Calls npm and npx

What it does

Convex Quickstart is an agent skill from spokvulcan/poker-planning. Creates or adds Convex to an app. Use for new Convex projects, npm create convex@latest, frontend setup, env vars, or the first npx convex dev run.

Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including assets (for example `agents/openai.yaml`).

It sits in Frontend & Design, covering Sprint planning and agile. It works with Convex, npm, shadcn/ui and Next.js. The repository describes itself as: Free open-source planning poker for Scrum teams. No registration required. Real-time estimation for remote agile teams. The licence is MIT.

When your agent uses it

  • New Convex projects
  • Npm create convex@latest
  • The first npx convex dev run

Example prompts

  • “Use the convex-quickstart skill to create or adds Convex to an app. An agent skill from spokvulcan/poker-planning”
  • “/convex-quickstart”

Requirements

  • Node.js

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Determine the starting point: new project or existing app
  2. If new project, pick a template and scaffold with npm create convex@latest
  3. If existing app, install convex and wire up the provider
  4. Run npx convex dev --once to provision a local anonymous deployment, push
  5. Ask the user (or, for cloud agents, start in the background) npm run dev —
  6. Verify the setup works

What it can do on your machine

Read from SKILL.md and the folder at commit 665a13f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    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.

  • Runs code

    Shell commands in SKILL.md call:

    • npm
    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.convex.dev

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Convex Quickstart loads about 3.5k tokens when it runs. Until then it costs about 41 tokens; SKILL.md has 1,428 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~41
When it runs · the whole SKILL.md, loaded when a task matches
~3.5k

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.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:100
    `.env.local`.
  • NoteMentions a .env fileSKILL.md:168
    .env.local        # CONVEX_URL / VITE_CONVEX_URL / NEXT_PUBLIC_CONVEX_URL
  • NoteMentions a .env fileSKILL.md:194
    write `.env.local`, generate types, push the current `convex/` code, and
  • NoteMentions a .env fileSKILL.md:316
    vex dev` writes the correct variable to `.env.local` automatically.
  • NoteMentions a .env fileSKILL.md:347
    3. `.env.local` contains a `CONVEX_DEPLOYMENT` value and the framework's
  • NoteMentions a .env fileSKILL.md:450
    - [ ] `.env.local` has the deployment URL

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.

SKILL.md

The full file from spokvulcan/poker-planning at commit 665a13f, republished under its MIT licence (© spokvulcan). 1,428 words, ~3,545 tokens.

Download SKILL.mdSave it as .claude/skills/convex-quickstart/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
convex-quickstart
description
Creates or adds Convex to an app. Use for new Convex projects, npm create convex@latest, frontend setup, env vars, or the first npx convex dev run.

Convex Quickstart

Set up a working Convex project as fast as possible.

When to Use

  • Starting a brand new project with Convex
  • Adding Convex to an existing React, Next.js, Vue, Svelte, or other app
  • Scaffolding a Convex app for prototyping

When Not to Use

  • The project already has Convex installed and convex/ exists - just start building
  • You only need to add auth to an existing Convex app - use the convex-setup-auth skill

Workflow

  1. Determine the starting point: new project or existing app
  2. If new project, pick a template and scaffold with npm create convex@latest
  3. If existing app, install convex and wire up the provider
  4. Run npx convex dev --once to provision a local anonymous deployment, push the current convex/ code, typecheck it, and regenerate types — all in one shot, exiting cleanly. The output tells the agent whether the schema and functions are valid.
  5. Ask the user (or, for cloud agents, start in the background) npm run dev — Convex templates wire the watcher and the frontend into a single command. If the project has no combined dev script, use npx convex dev for the watcher and run the frontend separately.
  6. Verify the setup works

Use the official scaffolding tool. It creates a complete project with the frontend framework, Convex backend, and all config wired together.

Pick a template
TemplateStack
react-vite-shadcnReact + Vite + Tailwind + shadcn/ui
nextjs-shadcnNext.js App Router + Tailwind + shadcn/ui
react-vite-clerk-shadcnReact + Vite + Clerk auth + shadcn/ui
nextjs-clerkNext.js + Clerk auth
nextjs-convexauth-shadcnNext.js + Convex Auth + shadcn/ui
nextjs-lucia-shadcnNext.js + Lucia auth + shadcn/ui
bareConvex backend only, no frontend

If the user has not specified a preference, default to react-vite-shadcn for simple apps or nextjs-shadcn for apps that need SSR or API routes.

You can also use any GitHub repo as a template:

bash
npm create convex@latest my-app -- -t owner/repo
npm create convex@latest my-app -- -t owner/repo#branch
Scaffold the project

Always pass the project name and template flag to avoid interactive prompts:

bash
npm create convex@latest my-app -- -t react-vite-shadcn
cd my-app
npm install

The scaffolding tool creates files but does not run npm install, so you must run it yourself.

To scaffold in the current directory (if it is empty):

bash
npm create convex@latest . -- -t react-vite-shadcn
npm install
Provision the deployment and push code

Run this yourself — it is a one-shot command that exits cleanly:

bash
npx convex dev --once

In a non-TTY environment (which is true for almost every agent run), this:

  • Provisions an anonymous local Convex backend bound to 127.0.0.1. No browser login, no team/project prompts.
  • Writes CONVEX_DEPLOYMENT and the framework's *_CONVEX_URL variables to .env.local.
  • Generates convex/_generated/.
  • Pushes the current convex/ code to the deployment, typechecks it, and validates the schema. The agent reads this output to find out if the code it just wrote is broken.

To be explicit (recommended), set CONVEX_AGENT_MODE=anonymous so the behavior does not depend on TTY detection:

bash
CONVEX_AGENT_MODE=anonymous npx convex dev --once

The deployment lives under ~/.convex/ and persists across runs. Re-running convex dev --once after editing convex/ files is the agent's main feedback loop while the user-launched npm run dev is not in use.

If the template's package.json defines a predev script (Convex Auth templates and similar do), npm run predev runs convex init plus any one-time setup (e.g. minting auth keys). Use it in addition to convex dev --once when present — predev handles the one-time setup, convex dev --once pushes and validates the code.

Start the dev loop

In most Convex templates, npm run dev runs both the Convex watcher and the frontend dev server together (typically convex dev --start 'vite --open' or the Next.js equivalent). That is what the user should run.

bash
npm run dev

If the project does not have a combined dev script — e.g. the bare template, or an existing app where you haven't wired the frontend dev server into Convex's --start flag — the user can run the Convex watcher directly:

bash
npx convex dev

npx convex dev is the same long-running watcher npm run dev invokes under the hood; it just doesn't start the frontend. Use it when there is no frontend, or when the user prefers to run the frontend in a separate terminal.

Either way, the agent should not invoke the watcher in the foreground because it does not exit. Two options:

  • Local development (user is at the keyboard): ask the user to run npm run dev (or npx convex dev) in a terminal. The deployment provisioned by convex dev --once above is already selected, so the watcher picks up immediately with no prompts.
  • Cloud or headless agents: start npm run dev (or npx convex dev) in the background.

Vite apps serve on http://localhost:5173, Next.js on http://localhost:3000.

What you get

After scaffolding, the project structure looks like:

my-app/
  convex/           # Backend functions and schema
    _generated/     # Auto-generated types (check this into git)
    schema.ts       # Database schema (if template includes one)
  src/              # Frontend code (or app/ for Next.js)
  package.json
  .env.local        # CONVEX_URL / VITE_CONVEX_URL / NEXT_PUBLIC_CONVEX_URL

The template already has:

  • ConvexProvider wired into the app root
  • Correct env var names for the framework
  • Tailwind and shadcn/ui ready (for shadcn templates)
  • Auth provider configured (for auth templates)

Proceed to adding schema, functions, and UI.

Path 2: Add Convex to an Existing App

Use this when the user already has a frontend project and wants to add Convex as the backend.

Install
bash
npm install convex
Show full SKILL.md (625 more words)Show less
Provision and push

Run npx convex dev --once yourself to provision a local anonymous deployment, write .env.local, generate types, push the current convex/ code, and typecheck it. This is one-shot and exits:

bash
npx convex dev --once

The output tells you whether the schema and functions are valid — use it as your feedback loop while iterating.

Then ask the user to start the watcher (or, for cloud/headless agents, start it in the background). You have two options:

  • Wire Convex into npm run dev — change the existing app's dev script to convex dev --start '<existing dev command>'. That's the standard pattern Convex templates use; the user then runs a single npm run dev to start both.
  • Run them separately — leave npm run dev for the frontend and tell the user to run npx convex dev in a second terminal for the Convex watcher.

See "Start the dev loop" above for why the agent should not run the watcher in the foreground.

Wire up the provider

The Convex client must wrap the app at the root. The setup varies by framework.

Create the ConvexReactClient at module scope, not inside a component:

tsx
// Bad: re-creates the client on every render
function App() {
  const convex = new ConvexReactClient(
    import.meta.env.VITE_CONVEX_URL as string,
  );
  return <ConvexProvider client={convex}>...</ConvexProvider>;
}

// Good: created once at module scope
const convex = new ConvexReactClient(import.meta.env.VITE_CONVEX_URL as string);
function App() {
  return <ConvexProvider client={convex}>...</ConvexProvider>;
}
React (Vite)
tsx
// src/main.tsx
import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { ConvexProvider, ConvexReactClient } from "convex/react";
import App from "./App";

const convex = new ConvexReactClient(import.meta.env.VITE_CONVEX_URL as string);

createRoot(document.getElementById("root")!).render(
  <StrictMode>
    <ConvexProvider client={convex}>
      <App />
    </ConvexProvider>
  </StrictMode>,
);
Next.js (App Router)
tsx
// app/ConvexClientProvider.tsx
"use client";

import { ConvexProvider, ConvexReactClient } from "convex/react";
import { ReactNode } from "react";

const convex = new ConvexReactClient(process.env.NEXT_PUBLIC_CONVEX_URL!);

export function ConvexClientProvider({ children }: { children: ReactNode }) {
  return <ConvexProvider client={convex}>{children}</ConvexProvider>;
}
tsx
// app/layout.tsx
import { ConvexClientProvider } from "./ConvexClientProvider";

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="en">
      <body>
        <ConvexClientProvider>{children}</ConvexClientProvider>
      </body>
    </html>
  );
}
Other frameworks

For Vue, Svelte, React Native, TanStack Start, Remix, and others, follow the matching quickstart guide:

Environment variables

The env var name depends on the framework:

FrameworkVariable
ViteVITE_CONVEX_URL
Next.jsNEXT_PUBLIC_CONVEX_URL
RemixCONVEX_URL
React NativeEXPO_PUBLIC_CONVEX_URL

npx convex dev writes the correct variable to .env.local automatically.

Agent Mode

CONVEX_AGENT_MODE=anonymous forces an unauthenticated local backend. It is already the implicit default for any non-TTY run of npx convex init or npx convex dev, but set it explicitly so the behavior does not depend on TTY detection:

bash
CONVEX_AGENT_MODE=anonymous npx convex dev --once

Use it for:

  • Any AI coding agent (local or cloud).
  • CI-like setup scripts.
  • Cases where the user is logged in but you do not want to touch their personal dev deployment.

The resulting backend runs on 127.0.0.1 and is not associated with any team or project until the user later claims it via npx convex login and the npx convex deployment commands.

Verify the Setup

After setup, confirm everything is working:

  1. npx convex dev --once exited without errors (deployment provisioned, code pushed, schema validated, typecheck clean)
  2. The convex/_generated/ directory exists and has api.ts and server.ts
  3. .env.local contains a CONVEX_DEPLOYMENT value and the framework's *_CONVEX_URL variable
  4. (If applicable) npm run dev (or npx convex dev for the watcher alone) is running without errors in another terminal or in the background

Writing Your First Function

Once the project is set up, create a schema and a query to verify the full loop works.

convex/schema.ts:

ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

export default defineSchema({
  tasks: defineTable({
    text: v.string(),
    completed: v.boolean(),
  }),
});

convex/tasks.ts:

ts
import { query, mutation } from "./_generated/server";
import { v } from "convex/values";

export const list = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db.query("tasks").collect();
  },
});

export const create = mutation({
  args: { text: v.string() },
  handler: async (ctx, args) => {
    await ctx.db.insert("tasks", { text: args.text, completed: false });
  },
});

Use in a React component (adjust the import path based on your file location relative to convex/):

tsx
import { useQuery, useMutation } from "convex/react";
import { api } from "../convex/_generated/api";

function Tasks() {
  const tasks = useQuery(api.tasks.list);
  const create = useMutation(api.tasks.create);

  return (
    <div>
      <button onClick={() => create({ text: "New task" })}>Add</button>
      {tasks?.map((t) => (
        <div key={t._id}>{t.text}</div>
      ))}
    </div>
  );
}

Development vs Production

Always use npx convex dev during development. It runs against your personal dev deployment and syncs code on save.

When ready to ship, deploy to production:

bash
npx convex deploy

This pushes to the production deployment, which is separate from dev. Do not use deploy during development.

Next Steps

  • Add authentication: use the convex-setup-auth skill
  • Design your schema: see Schema docs
  • Build components: use the convex-create-component skill
  • Plan a migration: use the convex-migration-helper skill
  • Add file storage: see File Storage docs
  • Set up cron jobs: see Scheduling docs

Checklist

  • Determined starting point: new project or existing app
  • If new project: scaffolded with npm create convex@latest using appropriate template
  • If existing app: installed convex and wired up the provider
  • Agent ran npx convex dev --once: deployment provisioned, code pushed, typecheck clean
  • npm run dev (or npx convex dev for the watcher alone) is running — user-launched terminal, or background for cloud agents
  • convex/_generated/ directory exists with types
  • .env.local has the deployment URL
  • Verified a basic query/mutation round-trip works

© spokvulcan, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (assets) in .agents/skills/convex-quickstart of spokvulcan/poker-planning.

  • SKILL.md
  • agents/openai.yaml
  • assets/icon.svg

Open the folder on GitHubat commit 665a13f

Used in 6 other repositories

We found 7 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 6 other GitHub owners. This page covers the copy in spokvulcan/poker-planning, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Convex Quickstart 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.

Convex Quickstart compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Convex Quickstart this skillspokvulcan/poker-planning1146 repos~3.5kAutomated safety check: NotesMIT
Convex Quickstartwaynesutton/markdown-site628—~1.2kAutomated safety check: NotesMIT
Creative Tim UI Blockscreativetimofficial/ui12k—~2.1kAutomated safety check: NotesMIT
Spotpatchhuanglvjing/spotpatch134—~998Automated safety check: PassMIT
Shadcn Tailwind UILiarMTTT/TavernWeave153—~1.7kAutomated safety check: PassCustom licence
Frontend Design UltimateaAAaqwq/AGI-Super-Team1052 repos~2.7kAutomated safety check: PassMIT

Similar skills

  • Convex Quickstart

    waynesutton/markdown-site

    Initialize a new Convex project from scratch or add Convex to an existing app.

    628 GitHub stars~1.2k tokensUpdated 4 mo ago
    Frontend & DesignAuto-check: notes

  • Creative Tim UI Blocks

    creativetimofficial/ui

    Helps install, generate and review Creative Tim UI blocks: shadcn/ui-based React and Tailwind sections that follow a restrained, production-minded design philosophy.

    12k GitHub stars~2.1k tokensUpdated 6 mo ago
    Frontend & DesignAuto-check: notes

  • Spotpatch

    huanglvjing/spotpatch

    为 React 项目建立从浏览器页面元素到精确 JSX/TSX 源码、结构化上下文与可审阅修改的 SpotPatch 工作流。用户提到 SpotPatch、截图沟通前端修改、页面元素定位源码、Vite 或 Next.js 接入、组件数据链路、结构化 Prompt、AI 补丁审阅、安装检查或故障排查时使用此技能。

    134 GitHub stars~998 tokensUpdated 11 days ago
    Frontend & DesignAuto-check passed

  • Shadcn Tailwind UI

    LiarMTTT/TavernWeave

    Build, restyle, or review accessible React interfaces that use shadcn/ui, Radix UI primitives, and Tailwind CSS.

    153 GitHub stars~1.7k tokensUpdated 5 days ago
    Frontend & DesignAuto-check passed

  • Frontend Design Ultimate

    aAAaqwq/AGI-Super-Team

    Create distinctive, production-grade static sites with React, Tailwind CSS, and shadcn/ui — no mockups needed.

    105 GitHub starsUsed in 2 repos~2.7k tokens
    Frontend & DesignAuto-check passed

  • Swc Plugin Compatibility

    B0und/WikiSpeedrun

    Diagnose and fix Lingui SWC plugin compatibility errors with Next.js, Vite, Rspack, or other SWC runtimes.

    133 GitHub stars~2.3k tokensUpdated 19 days ago
    Frontend & DesignAuto-check passed

More from spokvulcan/poker-planning

  • Convex Create Component

    spokvulcan/poker-planning

    Builds reusable Convex components with isolated tables and app-facing APIs.

    114 GitHub starsUsed in 8 repos~2.6k tokens
    Auto-check passed

  • Convex Migration Helper

    spokvulcan/poker-planning

    Plans Convex schema and data migrations with widen-migrate-narrow and @convex-dev/migrations.

    114 GitHub starsUsed in 8 repos~1.4k tokens
    Auto-check passed

  • Convex Setup Auth

    spokvulcan/poker-planning

    Sets up Convex auth, identity mapping, and access control. An agent skill from spokvulcan/poker-planning.

    114 GitHub starsUsed in 8 repos~1.8k tokens
    Auto-check passed

  • Convex Performance Audit

    spokvulcan/poker-planning

    Audits Convex performance for reads, subscriptions, write contention, and function limits.

    114 GitHub starsUsed in 7 repos~1.9k tokens
    Auto-check passed

  • Convex

    spokvulcan/poker-planning

    Routes general Convex requests to the right project skill. An agent skill from spokvulcan/poker-planning.

    114 GitHub starsUsed in 6 repos~399 tokens
    Auto-check passed

Works with

Categories

Questions about Convex Quickstart

What does Convex Quickstart do?

Creates or adds Convex to an app. An agent skill from spokvulcan/poker-planning. Convex Quickstart is an agent skill from spokvulcan/poker-planning. Creates or adds Convex to an app.

When should I use Convex Quickstart?

Convex Quickstart fits situations like: new Convex projects; npm create convex@latest; the first npx convex dev run.

How do I install Convex Quickstart in Claude Code?

Run `npx skills add spokvulcan/poker-planning --skill convex-quickstart -a claude-code`. Or copy the skill folder (.agents/skills/convex-quickstart in spokvulcan/poker-planning) into .claude/skills/convex-quickstart in your project. Claude Code loads it when a task matches its description.

How do I install Convex Quickstart in Codex?

Run `npx skills add spokvulcan/poker-planning --skill convex-quickstart -a codex`. Or copy the skill folder (.agents/skills/convex-quickstart in spokvulcan/poker-planning) into .agents/skills/convex-quickstart in your project. Codex loads it when a task matches its description.

Can I use Convex Quickstart in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add spokvulcan/poker-planning --skill convex-quickstart -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/convex-quickstart, .gemini/skills/convex-quickstart, .github/skills/convex-quickstart and .opencode/skills/convex-quickstart in your project.

What does Convex Quickstart need to run?

Going by SKILL.md and its folder, Convex Quickstart needs the command-line tools its instructions call (npm and npx). Our summary lists: Node.js.

Does Convex Quickstart access the network?

SKILL.md names 1 domain. As links in the text: docs.convex.dev. This is read from the text; nothing was executed.

Is Convex Quickstart safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Convex Quickstart use?

Convex Quickstart is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Convex Quickstart use?

About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Convex Quickstart?

Skills that share tags, products or a category with Convex Quickstart: Convex Quickstart (waynesutton/markdown-site, 628 stars), Creative Tim UI Blocks (creativetimofficial/ui, 12k stars), Spotpatch (huanglvjing/spotpatch, 134 stars) and Shadcn Tailwind UI (LiarMTTT/TavernWeave, 153 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Convex Quickstart?

spokvulcan (a GitHub user) maintains it in spokvulcan/poker-planning, which has 114 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on October 4, 2026.

Source: spokvulcan/poker-planning on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.