Contribute an example

The short version

1. Download and unzip the starter kit. It contains one complete example with a valid recipe.json, a Markdown article, a place for sanitized source code, and submission checklists.
2. Give the folder to your AI agent. Also give it the prompt below and whatever safe reference material it needs to understand your workflow.
3. Review every file yourself. Remove private information, credentials, personal paths, customer data, and anything you do not have permission to publish.
4. Compress the item folder. The ZIP should open to one plainly named folder containing recipe.json at its top level.
5. Upload the ZIP. Use the Zengobi support upload page and identify it as a Curio CLI Examples contribution.

You do not need to be a programmer. A contribution can be a narrative tutorial with screenshots, a reusable script, a small application, an agent workflow, or an integration with another tool.

What makes a useful contribution

An example should help another Curio user understand both the result and the workflow. Explain:

• the problem or repeated task you wanted to improve;
• what the finished workflow accomplishes;
• the specific jobs performed with the supported Curio CLI;
• how an AI agent, scripts, or other applications participate;
• whether the workflow reads from or changes Curio projects;
• how someone can reproduce or adapt it; and
• the limitations, safety boundaries, and lessons you discovered.

Include concrete commands or short code excerpts when they clarify the process. A useful explanation is more important than showing every implementation detail.

Instructions for your AI agent

Copy the following prompt and give it to your agent along with the unzipped starter kit. Add safe source material about your workflow after the prompt.

Prepare a submission for the Curio CLI Examples at
https://www.zengobi.com/curio/cli/examples/.

The attached starter kit contains the required folder structure, a working
recipe.json, an example content.md, and checklists. Read every file before
making changes. Replace the example with one self-contained example and
keep recipe.json at the top level of the item folder.

Describe the workflow for a general Curio user. Explain its background, the
problem it solves, what was automated or streamlined, the supported Curio CLI
actions it performs, how the agent and any scripts work together, how to use
or reproduce it, and its limitations or safety boundaries. Prefer a clear
narrative with concrete examples over promotional language.

Use only supported Curio CLI commands and documented behavior. Do not inspect,
reverse engineer, or describe Curio's internal project-file format.

Privacy and security are mandatory. Do not include real client, customer,
student, patient, employee, or case information. Remove names, email addresses,
credentials, API keys, private URLs, account identifiers, serial numbers,
machine-specific paths, project filenames, hidden metadata, and confidential
business details. Use fictional or generalized examples where necessary.
Never include an actual Curio project unless I explicitly approve a thoroughly
sanitized copy. Include only material I have permission to publish.

Sanitize screenshots, videos, logs, commands, configuration, comments, test
data, filenames, and source code—not just the written article. Keep secrets and
private configuration out of the ZIP. If the workflow needs credentials,
document environment-variable placeholders instead.

Complete recipe.json accurately. Use status "draft"; Zengobi will set the
publication status after review. Set capabilities.curio_access to "read" or
"write" based on the workflow's actual behavior. If selected source files
should be viewable on the example page, put sanitized copies beneath the folder
named by source_root. Include only files that help explain or run the example.

Use media/ for publication-ready images or MP4 video. Give every media item
useful alt text and a concise caption in recipe.json. Use downloads/ only for
an artifact that visitors should be able to download. Do not invent missing
media; instead, list what still needs to be captured.

Before finishing, follow SUBMISSION-CHECKLIST.md. Then report the completed
folder structure, any missing media, and any facts or privacy decisions that I
must personally verify. Do not create the final ZIP until I approve the review.

Folder structure

The starter kit uses this layout:

your-item-slug/
├── recipe.json
├── content.md
├── AGENT-INSTRUCTIONS.md
├── SUBMISSION-CHECKLIST.md
├── media/
│   └── README.md
├── source/
│   └── example.py
└── downloads/              optional
    └── your-download.zip   optional

Rename your-item-slug to a short, descriptive identifier made from lowercase letters, numbers, and hyphens. The folder name and the slug in recipe.json must match exactly.

Only recipe.json and content.md are required. Omit unused folders and fields rather than leaving misleading placeholders in the finished submission.

Writing content.md

This file becomes the main article on the example page. It uses Markdown. Organize it around what another user wants to learn:

1. Background: What were you doing before, and what made you seek a better workflow?
2. Outcome: What does the finished example produce or make easier?
3. How it works: Which Curio CLI commands or operations are involved?
4. Using it: What does another person need, and what steps do they follow?
5. Safety and limitations: Does it edit projects, write files, use the network, or depend on external services?
6. Ideas to adapt: What related workflows could use the same pattern?

Fenced code blocks are syntax-highlighted and receive a copy button. Specify their language when possible:

```bash
curio get project --format json

# A short, sanitized example

Use callouts for information a visitor should not miss:

```markdown
> [!NOTE]
> This workflow reads saved projects and does not change them.

> [!WARNING]
> This workflow changes the open project. Review the agent's plan first.

Writing recipe.json

recipe.json supplies the example card, requirements, safety labels, media, source browser, and optional download button. It must be valid JSON: use double quotes, do not add comments, and do not leave a trailing comma.

Identity and description

• schema_version: Use 1.
• slug: Must exactly match the containing folder and use only lowercase letters, numbers, and hyphens.
• title: A short human-readable title.
• summary: One sentence explaining the result and why it is useful.
• type: Use recipe, tutorial, or integration.
• categories: Broad groupings such as Agent workflows, HTML dashboards, or Reports and exports.
• tags: Specific technologies or Curio features such as Python, AI agents, Project Center, or PDF.
• published and updated: Dates in YYYY-MM-DD form.
• status: Contributors should use draft. Zengobi sets the final publication status.
• featured: Use false; Zengobi editors manage featured placement.
• author: Supply the public name and optional organization you want displayed. Use Anonymous contributor if you prefer not to be identified.

Requirements and capabilities

State only requirements you have verified. Typical requirements fields include:

• minimum_cli_version, minimum_curio_version, and minimum_macos_version;
• curio_edition and sustainer_required;
• curio_must_be_running;
• python; and
• dependencies, an array of other tools or agent skills.

The capabilities object is a trust and safety summary:

• curio_access: Use read if it only inspects Curio data or write if it can make any change.
• writes_files: Does it create or change files outside Curio?
• uses_network: Does it contact websites, APIs, cloud services, or AI services while running?
• installs_automation: Does it install a scheduled job, background process, or other automation?

When in doubt, choose the more cautious description and explain the details in content.md.

Media, source, and downloads

• card_media: A representative image beneath media/, such as media/overview.jpg.
• card_media_alt: A concise description of that image.
• gallery: An ordered array of images or MP4 videos. Each entry needs type, src, alt, and caption; videos may also have a poster image.
• source_root: A folder containing sanitized source files visitors may inspect. The source browser currently displays common text formats including Python, HTML, CSS, JavaScript, JSON, Markdown, TOML, YAML, shell scripts, lock files, and plain text. Individual displayed files must be smaller than 1 MB.
• download: An optional object with path, label, and version for a ZIP visitors may download.
• forum_url or video_url: Optional public links related to the example.

Do not point a field at a file that is not present in the submission.

Media guidance

Screenshots and short videos often explain an agent workflow better than paragraphs alone. Keep them focused:

• capture only the relevant Curio or companion-app area;
• use readable dimensions and avoid excessive compression;
• remove notifications, usernames, document titles, project names, and unrelated windows;
• inspect image metadata and video frames for private information;
• write alt text that conveys what a person needs to understand; and
• use captions to explain why each image matters, not merely what it depicts.

If a useful image is not ready, leave it out and mention it in your handoff. Zengobi can discuss media needs during review.

Privacy and publication review

Assume that every included file may become publicly downloadable. Search the complete folder for:

• names and contact information;
• client, case, health, school, financial, or personnel data;
• API keys, tokens, passwords, license information, and private URLs;
• local usernames and absolute file paths;
• real project, idea space, and document names;
• private comments, commit history, logs, test fixtures, and configuration; and
• copyrighted or third-party material you cannot redistribute.

Use fictional data rather than masking only part of a real record. If anonymizing the workflow would make it misleading, describe the pattern without submitting the sensitive artifacts.

Package and submit

Before compressing, open the finished folder fresh and confirm that:

• recipe.json parses as JSON and its slug matches the folder name;
• every referenced media, source, and download path exists;
• the instructions and requirements are reproducible;
• the privacy checklist covers source, media, and metadata; and
• there are no caches, virtual environments, build products, dependency folders, .git data, or unrelated large files.

In Finder, select the single item folder and choose Compress. Upload the resulting ZIP at the Zengobi support upload page. Enter your email address and use a comment such as:

Curio CLI Examples contribution: Your Item Title
Public author credit: Your Name / Anonymous contributor

Keep the ZIP within the size limit shown on the upload page. If your publication-ready media makes it too large, upload the core contribution first and explain what additional files are available.