Agent workflows for Codex & Claude Code

Your next step, well prepared.

Cookbook by Pengusto is a collection of thirteen agent skills. They help you and your agents start projects with purpose, review your work and hand over clear results.

Install Explore the skills

Thirteen skills. A better workflow.

Green Cookbook with a frying pan and fried egg, the visual identity of the skill collection.

Thirteen skills. Each has its place.

Find the right skill

The same thirteen workflows. Choose the names that work for you.

How Do I Start?

Start small: turn an idea into the next verifiable project step.

When to use it: You have an idea but need a concrete first step.
What you need: A product idea or repository, audience, constraints and existing conventions. No account access required.
Workflow: Understand the project, resolve only necessary choices and implement the authorized slice without mandatory tickets.
Verification: The next step has an observable outcome; open decisions stay explicit.
Result: A compact project starting point with recommendations and, when confirmed, useful artifacts.
Limits: Extra modules and tracking are optional. Brainstorming does not authorize implementation; existing approval is retained.

$how-do-i-startDownload this skill Skill instructions

Am I Making Progress?

Briefly check whether the current approach serves the goal.

When to use it: Many attempts, unclear progress or a suspected detour.
What you need: The current conversation, agreed goal, relevant results and checks.
Workflow: Compare the known goal, evidenced progress and main obstacle; recommend the next useful decision.
Verification: Cooking, Stalled, Side quest or Unclear is supported by evidence.
Result: A brief course correction and next step.
Limits: Diagnosis alone does not authorize new changes. Historical pattern analysis is optional.

$am-i-making-progressDownload this skill Skill instructions

Where Were We?

After a pause, recover the goal, current state and open work.

When to use it: After a break or a long conversation, the agreed goal, completed work or open items are unclear.
What you need: Available history of this conversation, later goal decisions and verified outcomes.
Workflow: Reconcile goals and later decisions, recap briefly and identify missing history.
Verification: Approved goal changes are distinguished from suggestions; missing history and unverified outcomes stay explicit.
Result: A compact recap of the current state and a useful next step.
Limits: Recap only: no file edits, task-status changes, automations or automatic resumption of remaining work.

$where-were-weDownload this skill Skill instructions

Did I Leak?

Review the working tree and Git history for sensitive content and coverage gaps.

When to use it: Before sharing a repository or preparing to make it public.
What you need: A Git repository, Python 3 and Git. Gitleaks and TruffleHog are optional; coverage stays explicit.
Workflow: Run a redacted scan; assess findings, missing scanners and unreadable files.
Verification: Working tree and reachable history are covered; missing scanners and remaining checks are documented.
Result: GO, GO WITH REVIEW or NO-GO, with concrete reasons.
Limits: No proof of complete security. No credential rotation, history rewrites or publication without approval.

$did-i-leakDownload this skill Skill instructions

Will They Sue Me?

Review a specific product flow or launch for evidence-backed gaps.

When to use it: An app or website needs a technical review before launch or after changes.
What you need: Repository, real data flows, operator and markets; browser and test data; current primary sources for legal claims.
Workflow: Set review depth, trace relevant flows and obligations, and propose scoped fixes with acceptance checks.
Verification: Each finding has evidence, a basis, a review date and acceptance criteria; unknown applicability stays open.
Result: A prioritized review table and concrete remaining questions.
Limits: No legally safe or lawsuit-proof promise; no real payments, deletions or external actions for testing.

$will-they-sue-meDownload this skill Skill instructions

Am I Ready to Share?

Make a repository shareable with suitable documentation and a verified installation.

When to use it: The product works locally but documentation, installation or release boundaries are missing.
What you need: Repository, Git status, installation flow, existing documentation and licenses.
Workflow: Evaluate first, implement relevant authorized changes and avoid mandatory languages or generic file lists.
Verification: Quickstart and package agree; local, committed, pushed and deployed remain distinct.
Result: A reviewable repository with explicit publication gates.
Limits: Preparation does not authorize publication. Clarify new licenses and scope; avoid a blanket file checklist.

$am-i-ready-to-shareDownload this skill Skill instructions

What Did We Change?

Write change notes that distinguish releases, fixes and uncommitted work.

When to use it: A version or first release needs understandable change notes.
What you need: Git repository, target ref and suitable base ref or first release; GitHub access is optional.
Workflow: Justify target and base, clarify ambiguity and accurately describe evidenced changes and repaired regressions.
Verification: Every claim is supported by the selected changes; versions and verification status are accurate.
Result: Release notes as text, without publication.
Limits: Invoking the skill does not authorize tags, releases or file changes. Omit claims without reliable evidence.

$what-did-we-changeDownload this skill Skill instructions

Can We Finish?

Close a chat briefly with evidence, or pause with a deliberate handoff.

When to use it: The current conversation should wind down, end or be continued later.
What you need: The agreed goal, existing results, open work and relevant checks.
Workflow: Reuse existing checks, finish authorized remaining work and briefly state completion, open work and any needed re-entry.
Verification: Completed work has evidence; open, deferred and blocked items remain visible.
Result: A verified finish or concrete handover with a way to resume.
Limits: Guide-only and pause modes do not change files or task status. No blind TODO completion, publishing or automatic archiving.

$can-we-finishDownload this skill Skill instructions

Here We Go Again

Inspect recurring failures and recommendations without follow-through.

When to use it: When attempts repeat or accepted recommendations remain unfinished.
What you need: Relevant history, artifacts and verified outcomes within the agreed scope.
Workflow: Bound the evidence; identify causes; reconcile advice; propose prevention.
Verification: Every pattern has a source; single incidents and hypotheses remain distinct.
Result: A ranked retrospective with recommendation status and a checkable improvement.
Limits: A report alone does not authorize fixes, rule edits, tickets or reminders.

$here-we-go-againDownload this skill Skill instructions

Catch Me Up

Return to a project after a long break with current context.

When to use it: When goals, decisions and the current state need refreshing.
What you need: Available chat, handoff and relevant current project artifacts.
Workflow: Recover the last agreed state; check relevant current facts; explain changes; recommend a reentry point.
Verification: Old reports and current checks remain separate; missing history stays visible.
Result: A compact project reentry with purpose, decisions, today’s state and one next step.
Limits: Do not resume implementation automatically or infer current deployment from old claims.

$catch-me-upDownload this skill Skill instructions

Finish My Prompt

Complete a partial prompt using visible context.

When to use it: When autocomplete is unavailable or a sentence is unfinished.
What you need: Prompt fragment, visible context, intended outcome and existing limits.
Workflow: Read the draft; preserve intent; fill the gap; return a copyable suggestion.
Verification: No invented facts or expanded scope; the proposed prompt is not executed.
Result: An editable complete prompt or the requested suffix only.
Limits: Manual drafting fallback; no native Tab integration or exact autocomplete-model claim.

$finish-my-promptDownload this skill Skill instructions

Which Name Wins?

Find fitting names and compare Plain/Kitchen pairs together.

When to use it: When a product or skill needs a name or a consistent name pair.
What you need: Purpose, audience, tone and relevant existing names; no private corpus required.
Workflow: Understand the use moment; create pairs; check collisions; recommend a choice.
Verification: Both variants name the same capability; choices remain distinct from suggestions.
Result: Ranked pairs with both invocation IDs and a short rationale.
Limits: No unverified availability claim and no renaming inferred from a question.

$which-name-winsDownload this skill Skill instructions

Explain the Cookbook

Understand Cookbook, choose a fitting skill and invoke it correctly.

When to use it: When getting started or unsure which workflow fits your situation.
What you need: Available skills, installed naming style, your question and desired result.
Workflow: Explain the collection; distinguish similar purposes; recommend a skill; show its invocation.
Verification: Only available invocations are presented as installed; display names and IDs remain distinct.
Result: Clear orientation, one fitting recommendation and an editable example.
Limits: Explains and recommends; no automatic execution, installation or approval.

$explain-the-cookbookDownload this skill Skill instructions

Clear workflows. Results you can review.

Install all thirteen skills

How it works

From the right moment to the next step.

Find your moment

Starting a project, checking progress, reviewing or wrapping up? Open the skill that matches your current question.

Choose your names

Kitchen names or Plain questions: install one variant. Both contain the same workflow instructions and tools.

Work with your agent

Install for Codex or Claude Code, invoke the skill and review the results. Open questions and approvals stay explicit.

Plain questions

Choose once. Use in your environment.

Codex takes two commands. Verified ZIPs are available for Claude Code and offline installation. Install thirteen skills in one naming style.

Codex

Download package

Install Codex directly from the verified GitHub marketplace. No extraction needed:

codex plugin marketplace add pengusto/cookbook --ref plain
codex plugin add cookbook-by-pengusto@cookbook-by-pengusto-local

Then start a new host session. The corresponding CLI must be installed and signed in.

Claude Code

Download package

Extract the complete ZIP, including hidden folders. In your terminal, enter the outer cookbook-by-pengusto folder, then run:

claude plugin marketplace add . --scope user
claude plugin install cookbook-by-pengusto@cookbook-by-pengusto-local --scope user

Then start a new host session. The corresponding CLI must be installed and signed in.

Already installed? Updates and switching variants

A new ZIP does not automatically replace an active installation. Keep a copy of the previous package and reinstall the updated version using your host’s plugin manager. In the Cookbook repository: git pull --ff-only and python3 scripts/launch_check.py.

Enable only one naming style per host. When switching, keep a backup, uninstall the previous Cookbook plugin, remove only its marketplace and register the new package folder. Deliberately replace older standalone copies or vibe-coding-cookbook first to avoid duplicate skills.

The website is available in German and English. Skill names and invocation IDs remain stable; switching website language does not translate the skill instructions.

Verify downloads with SHA-256 · MIT

Good tools need clear boundaries.

Built by Pengusto for working with agents: thirteen focused workflows maintained in one shared source. The skills guide your work, make checks traceable and keep decisions in your hands. The pictured cookbook is a brand illustration, not a physical product.

Public Beta 0.5.0 with thirteen workflows. Package and portable-build checks; earlier acceptance records are version-specific. No store approval or security/legal certification.