Felo SuperAgent on PiPi Coding Agent

Package artwork is a long job. It should not hold the session.

A favicon, a logo lockup, or a README diagram is work with its own states and its own memory. Felo SuperAgent keeps that work on a persistent canvas, so you check in on it instead of watching it.

  • Bundlefelo-skills/felo-superagent
  • InputA brief in words
  • Comes back asFiles, plus the run that made them
  • State livesOn the canvas, not in the session
Built for PiRuns on a canvasStops for your call
Get an API keySee the platform guide
Copy it incp -r felo-skills/felo-superagent ~/.pi/agent/skills/
Pi Coding Agent logo
This skill runs on

Pi Coding Agent

Minimal terminal coding harness

Read the Pi Coding Agent guide

Pi keeps a deliberately small core and asks you to extend it, so a skill is the intended way to add reach without adding tools to maintain.

Loads from
~/.pi/agent/skills/ · .pi/skills/ · packages
Install is
A folder copy, or pi install npm:@scope/pkg
Worth knowing
No sandbox — read the SKILL.md before you mount it
What you get back

A job with states you can interrupt, not a spinner

The interesting part of a long generation is where it pauses. This one stops when taste is the deciding factor, which is the difference between a tool that helps and one that produces work you throw away.

  1. Running

    Reading the brief

    The package name, the job it does, and the two places the mark has to work: a 16px favicon and a README header.

  2. Running

    Three directions, first pass

    A geometric monogram, a literal glyph, and a mark built from the shape of the package's own output.

  3. Blocked

    Waiting on your call

    Two directions survived review. The third reads as a different product at small sizes, so it stops rather than spending more effort on it.

  4. Done

    Exported

    SVG and PNG at the sizes the repository actually uses, with a one-line rationale beside each file.

The routine

Getting a small project to a mark you can commit

Constraints first, directions second, files last. It is the order that keeps the run short.

Runs when

The repository needs a mark — a favicon, an icon set, artwork for the README — and there is no designer in the loop.

  1. 01

    Write the brief as constraints

    Name the sizes it has to survive and the two places it will appear. "A modern logo" gives the run nothing to check against, so it optimises for nothing in particular.

  2. 02

    Ask for directions, not a final

    Three directions cost less to reject than one polished mark you do not want. The first pass is for choosing, not for shipping.

  3. 03

    React at the size that matters

    Look at the candidates at 16px before anything else. Most marks fail there, and it is cheaper to find that out before the export step.

  4. 04

    Keep the rationale with the files

    Whoever touches the brand next needs to know why the mark looks like this, and which direction was rejected.

Leaves behindSVG and PNG assets at the sizes the repository uses, plus a short note on the directions that were rejected and the reason.

Add it on Pi

Mount it anywhere; the run lives somewhere else

The bundle is small and the work is not, which is why the root you choose barely matters here. What matters is that the canvas — not the session — is holding the state.

  1. 01
    ~/.pi/agent/skills/Global

    Every project on this machine. Put a bundle here once you have read it and want it everywhere.

  2. 02
    ~/.agents/skills/Shared

    The folder other harnesses read too, so one clone serves Pi and whatever else you run.

  3. 03
    .pi/skills/Project

    This repository only, and only after you trust the project. The right place to evaluate a bundle you have not read yet.

  4. 04
    pi install npm:@scope/pkgPackage

    A package's skills/ directory, kept versioned and updatable. The cleaner route once a bundle earns a permanent place.

Or load it for one session, without copyingpi --skill /path/to/felo-superagent
In practice

Two prompts that keep the run short

Both hold the job at the reviewable stage instead of letting it run to a finished artifact you may not want.

Type thisSketch three directions for this package's icon, show them at 16px and at 256px, and stop before exporting.What comes back

Three candidates at both sizes with a one-line rationale each, held for your pick rather than exported.

Type thisThe mark is too detailed at small sizes. Reduce it to something that still reads as the same product.What comes back

A simplified variant beside the original, so you can see exactly what was dropped and what survived.

Check it worked

Three signs the run is worth continuing

Image generation is cheap to start and expensive to review, so the checks are about whether it is respecting your time.

1

There are states, not a spinner

You should see where the run is and what it is waiting for. A job you cannot interrupt is a job you will stop starting.

2

It stops for taste

A run that guesses at your judgement produces work you discard. A blocked state at the right moment is the feature, not a failure.

3

Exports match the manifest

Check the delivered sizes against what the repository asks for. A mark delivered at one size leaves you doing the resizing anyway.

FAQ

What Pi users ask about Felo SuperAgent

Does the image generation happen locally?
No. The bundle calls Felo's service through the CLI, so the machine running Pi sends the brief and receives the files, nothing more.
Can I interrupt a run that is going the wrong way?
That is the reason to use it here. The canvas keeps the state, so redirecting it is a message rather than a restart.
What do I commit to the repository?
The exported files and the note that explains them. The run itself lives on the canvas and is not part of the repository.
Is it a replacement for a designer?
No. It gets a small project to a usable mark and tells you what it could not decide, which is the part worth a human.
More on Pi Coding Agent

Every Felo skill for Pi Coding Agent

Five skills written for Pi Coding Agent. They follow the same pattern on this platform, so you can combine them in one session without re-explaining your setup.

Beyond ready-made skills

One API key. A full agent toolkit.

Start with a skill, then compose the exact models, live data, knowledge, and output tools your Pi workflow needs — the same key every Felo skill already uses.

Models

Use cost-efficient LLM access when your agent needs custom reasoning or generation.

  • LLM API
  • Chat completions
  • Model access
Explore LLM API →

Live information

Give agents current web and social signals instead of relying on stale context.

  • Web Search
  • X Search
  • Web Fetch
Explore live data tools →

Knowledge and output

Ground work in reusable knowledge, then turn it into shareable deliverables.

  • LiveDoc
  • PPT generation
  • Mindmaps
Explore knowledge tools →

Creative tools

Extend the workflow from research to visual and office-ready results.

  • Image generation
  • Page tools
  • Office outputs
Explore platform tools →