Skip to content
cccskills
FreePublished on GitHubEnglish overview

kortix-artifacts

Publish project files as shareable artifacts with the `kortix artifacts` CLI. Create editable Markdown docs that can be exported as PDF, or HTML pages for decks, dashboards, mockups, and tools; manage versions and share them with project members, selected people, or link holders.

OriginalShow the original description

Share work from the project's Drive as artifacts with the `kortix artifacts` CLI: a `doc` (a Markdown file people read and edit in place, exportable as PDF) or an `html` page (a slide deck, dashboard, mockup, tool or app). The files stay plain files in Drive; every save is a version from the Drive history; people open artifacts in the Kortix app under Artifacts and share them with the project, chosen people, or anyone with a link. Load when the user asks for a doc, report, write-up, plan, proposal, spec, decision record, comparison, deck, slides, presentation, dashboard, tracker, mockup, tool, page, or anything meant to be read, kept or shared; when a reply would run past a screen of structured content; or when the user names an artifact or an artifact link.

kortix-ai/suna20,332 stars(GitHub 20,332 + cccskills 0)

Run score Not tested

See how to install

Good for

  • Publishing a Markdown report for people to read and edit
  • Sharing an HTML slide deck or dashboard with a project
  • Updating an existing artifact while keeping its version history
  • Adding a folder already stored in project Files as an artifact

Overview

What it does

This skill turns ordinary files in a project’s Files into artifacts that are easier to view and share. Use a Markdown doc for text-focused plans, specifications, and reports. Use an html page for slides, dashboards, mockups, or tools that need layout, charts, or interaction. With the kortix artifacts CLI, you can publish new artifacts, save changes to an existing one, list and view artifacts, share them, and inspect or restore versions. Each save creates a version in Files history, and artifacts can be opened from Artifacts in the app.

When it helps

Use it when a plan or comparison is too long for a chat reply and needs to be revisited, edited, or shared with a team. Short answers and code changes do not need an artifact. When revising an existing artifact, save to that same artifact.

Example requests

  • “Publish this as an editable plan in Artifacts.”
  • “Share the folder in the project’s Files as an artifact.”
  • “Update the existing dashboard and share it with the team.”

Notes

The kortix artifacts CLI needs write access to Files, and publishing or sharing also involves artifact permissions. New artifacts are private by default; sharing with the project or selected people must be set explicitly. Anyone can open a public link without logging in, so check before making one public. Do not publish secrets, tokens, or customer data.

This overview was written by AI (OpenAI Codex) from the public SKILL.md. Check the original below for the exact behavior.

Document check

AI checked the SKILL.md for operations that need care and for setup requirements. The score comes only from actually running the skill (hands-on test).

SafetyAre sending data, deleting files, and running commands disclosed?
BPartly lackingIt warns about public links and sensitive data, but gives limited publication checks.
Easy setupDoes it need few tools or API keys, and are they documented?
BPartly lackingIt requires the CLI and Files write and artifact permissions.

Not counted in the score. Rated by AI (OpenAI Codex) as of Oct 28, 2026. Treat it as a guide and read the original before installing.

Disagree? Request a re-evaluation

Tell us which point is wrong and why. No login needed. We will check it against the SKILL.md, redo the evaluation, and show the result here.

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

Files included (3)

  • SKILL.md11.2 KB
  • references/design.md9.8 KB
  • references/diagrams.md3.1 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

<skill name="kortix-artifacts"> <checklist> Before every publish: 1. **Title = a name**, 2–4 words, no colon, dash or arrow: `--title "Scheduler migration"`, never `--title "Scheduler migration: off the cron VM"`. The explanation goes in `--description`. 2. **Share when asked.** "So the team can review it", "share with the team" or "for the project" → add `--visibility project`, on the publish or with `kortix artifacts share <id> --visibility project`. In a private channel (`/drives/README.md` says so) never use `--visibility project` or `public`: the artifact stays private to the channel's members. 3. **Answer first**: the recommendation or result is the first paragraph. 4. **One artifact per thing.** Revising an existing one? Save into it (`--id`). 5. **Hand it over with `show`**: `url` = the artifact's app link, `title` = its name. The user sees it in the chat and opens it beside the chat. Then one line on what it shows. </checklist> <overview> An artifact is a folder in the project's Drive, shared. Its files are ordinary files (`index.md` for a doc, `index.html` plus its images and scripts for a page). The artifact adds a place in the Artifacts gallery, a viewer, version history (the Drive history of that folder) and share links. Keep a code change in the repository.

Before you write one, read references/design.md (the page contract and the design method). For any diagram, read references/diagrams.md. </overview>

<when> Make an artifact when the result is something the user will read, keep, share, present or come back to: a plan, a spec, a report, a comparison, a deck, a dashboard, a tool. Also make one when an answer would run past about a screen of structured content (headings, tables, steps).

Answer in chat when the answer is a few sentences, a quick fact, or a short list. A code change belongs in the repository, not in an artifact.

Change the existing artifact when the user asks to revise, extend or fix one. Never publish a second copy (see <update>). </when>

<method> 1. **Read the request.** Name the subject, the reader and the page's single job. Choose the type: - **doc** for words people read and edit (plans, specs, reports, memos); - **html** for anything that needs layout, charts, interaction or slides.

Choose the treatment (utilitarian, UI or editorial) from references/design.md. 2. Gather real content first. Get real numbers with units and dates, real names of things, the user's own terms. Never use lorem ipsum. If data is missing, the page says so. 3. Plan. For html, write the token plan (colors, type roles, a layout line) as the :root block before anything else. For a doc, write the heading outline first. 4. Write it once, well. Lead with the answer. Follow the fundamentals in references/design.md. 5. Name it. Give it a --title and a one-sentence --description (rules below). 6. Publish, look once, fix once. See "Check once" in references/design.md. No loops. 7. Hand it over. Call show with the app link (url) and the name (title): the chat shows the artifact itself, and the user opens it beside the chat. End your reply with one line on what the artifact shows. Never paste its content into the chat. Mention the design in at most one plain sentence. </method>

<naming> The title is the artifact's name in the gallery, beside dozens of others. - Write a name, not a caption: a short noun phrase, usually 2–4 words, specific to the subject ("Q3 churn report", "Pricing page v2", "Card deck"). A page that answers one question may take that question as its name. - Use the user's own name for the thing when they have one. - Never use a bare category ("Report", "Dashboard", "Plan"). Never add an explanation after a dash, a colon or an arrow:
WrongRight
Docs search migration: hosted vendor → Postgres FTSDocs search migration
Q3 Report – churn, revenue and retentionQ3 churn report
DashboardSupport queue health

Pass the name with --title. The doc's own # heading may say more.

  • Put the explanation in --description, one sentence: the gallery shows it under the title.
  • Keep the title stable across saves. </naming>
<planning> Plans, proposals and decision records are the most common artifact. Make each one a **doc**, in this order. Skip a section that has nothing true to say.
  1. # <Name>, then the recommendation or the decision asked for in the first paragraph: what to do, by when, and what it costs in time or risk.
  2. The problem, stated as the problem ("signups drop 40% at the email step"), not as a pre-chosen solution.
  3. Options: a table, one row per option, with columns for what matters (effort, risk, reversibility, what it unblocks). If the options differ in structure, add one mermaid diagram that shows the difference.
  4. The plan: numbered steps, each with an owner or a done-when.
  5. Risks and unknowns: one line each (what, why it matters, what resolves it).
  6. Next steps: a task list (- [ ]) the reader can tick in the doc.

Write it for a reader who decides without asking you a question. Revise the same artifact as the plan changes: its history keeps every earlier version. </planning>

<types> | Type | For | The file | |---|---|---| | `doc` | specs, reports, memos, plans | a **Markdown** file (`report.md`). Kortix renders and styles it; people edit it in place and export it as PDF. | | `html` | decks, dashboards, mockups, tools | an **HTML** file, or a folder with `index.html` and its assets. Served exactly as written. |

kortix artifacts types <type> prints the format rules and a starter.

doc: one # Title, then headings, paragraphs, bold, italic, code, links, bulleted, numbered and task lists (- [ ]), quotes, code blocks, tables, ```mermaid diagrams, images and videos (files in media/ next to index.md, referenced relatively), ---. No HTML layout, CSS or scripts. Need charts or layout? Make an html artifact.

html: a complete page, served exactly as written: write the <!doctype>, the viewport meta and the <title> yourself. It runs sandboxed (no cookies; storage may throw; no access to Kortix). Its images, data and scripts sit in the same folder and load by relative path. Load libraries from a CDN at a pinned version (Chart.js for charts, Reveal.js for decks). It must work from 400 px to a large screen and in light and dark. The full contract is in references/design.md. </types>

<publish> Two ways, same result:
kortix artifacts publish report.md --title "Q3 churn report"   # uploads to your Artifacts folder in Drive
kortix artifacts publish ./deck                                 # a folder with index.html
kortix artifacts add /Company/Plans/roadmap                     # shares a folder already in Drive (index.md or index.html)

A .md file is a doc; anything else is html. The command prints the artifact id, its path in Drive and its app link. Hand it over with show (the app link as url) and one line on what it shows. Never paste the content into the chat.

A new artifact is private: the person who runs this session (and you) can see it. Share it when the user asks. "Share it with the team", "something the team can review" or "for everyone on the project" each mean --visibility project; pass it on the first publish. Named people mean --with. Only an explicit "public" or "anyone with the link" means public:

kortix artifacts share <id> --visibility project        # every project member
kortix artifacts share <id> --with ada@example.com      # chosen people (private)
kortix artifacts share <id> --visibility public         # anyone with the link

Ask before public: a public link works without a login. Never publish secrets, tokens or customer data. </publish>

<update> Change the artifact, never publish a second one. Edit its file in Drive, or:
kortix artifacts pull <id> ./work                       # prints the entry_version
# edit ./work/<file>
kortix artifacts publish ./work/<file> --id <id> --base-version <entry_version>

--base-version refuses the save (exit 3, version_conflict) when someone saved after you pulled, for example a person editing the doc: pull again, merge, save. kortix artifacts versions <id> lists every save from the Drive history; restore <id> <version-id> writes one back as a new save. kortix artifacts rm <id> stops sharing; the files stay in Drive. If the request also asks to share ("so the team can review it"), share the artifact you saved: kortix artifacts share <id> --visibility project. </update>

<quality> - Say the answer first: the doc's opening paragraph, the deck's title slide, the dashboard's header. - Real content only. Every number has a unit and a date. Every chart is drawn to scale. - Decks: one idea per slide, large type, arrow keys to move. - Never publish secrets, tokens or customer data. Use synthetic examples marked as examples. </quality> <commands> | Command | Does | |---|---| | `kortix artifacts types [<type>]` | types; one type's format and starter | | `kortix artifacts publish <file\|dir> [--title --description --visibility]` | upload and share | | `kortix artifacts add <folder> [--title --visibility]` | share a folder already in Drive; an artifact is always a folder, so a lone file is refused (publish it instead) | | `kortix artifacts publish <file\|dir> --id <id> [--base-version v]` | save new content | | `kortix artifacts ls [--mine\|--shared\|--pinned] [--type t] [--search q]` | list | | `kortix artifacts info <id>` / `open <id>` | details, path, links | | `kortix artifacts cat <id> [path] [--version v]` / `pull <id> <dir>` | read | | `kortix artifacts share <id> --visibility … [--with …]` | share | | `kortix artifacts versions` / `restore` / `rename` / `pin` / `unpin` / `rm` | manage |

Add --json for machine-readable output. Permissions (a role's, and for an agent its kortix_permissions in kortix.yaml):

PermissionLets you
project.artifact.readlist, open, read versions and files
project.artifact.writepublish, add, save, restore; rename and share your own
project.artifact.managerename, share or stop sharing anyone's
project.artifact.publicgive an artifact a public link

Saving also needs write access to the folder in Drive. A refused public link answers 403 public_link_forbidden: share with the project instead and tell the user. </commands>

</skill>

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

access-policy

FreeSummary

Review Slack access requests against Okta role and team information, then prepare narrowly scoped GitHub or AWS IAM permissions. Apply changes only after an eligible person's approval and record the grant, reasoning, approver, and timestamp.

  • Reviewing GitHub repository access requests from Slack
  • Preparing AWS IAM permissions for a specific task
  • Routing sensitive access requests for additional review
kortix-ai/suna20.3KUpdated Oct 30, 2026

account-research

FreeSummary

Research companies and people before outreach or meetings. Combines business profiles, recent news, hiring signals, and key contacts into a sourced brief with talking points and suggested questions, adding relationship history when CRM data is connected.

  • Research a prospective customer before outreach
  • Prepare background information for meeting attendees
  • Compare a competitor's products and positioning
kortix-ai/suna20.3KUpdated Oct 30, 2026

Review daily Google Ads and Meta Ads results for budget pacing, declining performance, and unusual activity. Get prioritized findings with supporting numbers and concrete recommendations for a marketing team to assess and carry out.

  • Checking whether campaign budgets are being spent on schedule
  • Investigating rising acquisition costs or falling ad returns
  • Finding ads and keywords that spend without converting
kortix-ai/suna20.3KUpdated Oct 30, 2026

agent-browser

FreeSummary

Automate website tasks such as navigating pages, filling forms, clicking buttons, taking screenshots, and extracting data. The skill also supports web app testing, with specialized guides for Electron desktop apps, Slack, and cloud browsers.

  • Automate form entry and page navigation
  • Capture screenshots and extract page data
  • Explore web apps for bugs
kortix-ai/suna20.3KUpdated Oct 30, 2026

ap-invoice-match

FreeSummary

Process emailed vendor invoices by extracting details, comparing them with purchase orders and invoice history, and recording duplicates, overcharges, or missing orders. Summarize results in Slack for human review; payment approval and execution remain with people.

  • Checking incoming invoices against purchase orders
  • Finding duplicate invoices and likely resends
  • Reviewing unit prices and remaining order balances
kortix-ai/suna20.3KUpdated Oct 30, 2026

billing

FreeSummary

Guide changes to Kortix billing code, admin controls, and pricing screens. Explain how plans, trials, enterprise contracts, and access exceptions should work, where pricing is defined, and which audited routes must handle account changes.

  • Update billing logic and its specification together
  • Review how trials and enterprise contracts are handled
  • Find the code that defines prices and allowances
kortix-ai/suna20.3KUpdated Oct 30, 2026

See all skills by kortix-ai

Report a problem with this skill