⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

agent-starter-pack

aka-kika@aka-kika⭐ 12 stars· last commit 16d ago· 0 open issues

Use when creating a new project folder, starter pack, app scaffold, or agent-ready workspace — AGENTS.md, README, TASKS, DECISIONS, PROMPTS, an idempotent bootstrap script, and starter-pack modes.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 12 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

akakika-skills

A small, carefully curated set of agent skills for building calm, native-feeling software — and for running AI coding agents well.

Apple/macOS design craft · SwiftUI · AI-agent workflows · project intelligence · upkeep · launch polish.

skills categories format license

Browse the collection at akakika-skills.vercel.app — every skill, searchable, with copy-paste installs.


These are agent skills — plain SKILL.md files that teach an AI coding agent how to do one thing well. They work with Claude Code, Codex, Cursor, and anything else that reads the SKILL.md format. No build step, no dependencies — open one and read it.

This isn't a dump of everything I've made. It's only what I'd hand to someone — each skill stripped down, de-branded, and polished to the same bar. The through-line is taste: calm UI, native patterns, privacy by default, project upkeep that won't bite you, and agent workflows that don't fall apart on the second run.

The collection follows the life of a project — decide, design, build, run, maintain, launch, tell people, close the session well:

Project intelligence · Design · Apple HIG · Swift & macOS · AI agent workflows · Session rituals · Maintenance · Launch & review · Content & publishing

If you only grab three: new-project-gate before you build, apple-hig-command-palette while you design, macos-permissions-privacy when macOS says no.

Quickstart

Install everything on a Mac (recommended)

One-liner — clones (or updates) the repo under ~/Projects/akakika-skills and symlinks all 40 skills into every agent skill directory it knows about (Claude Code, Grok, Goose, Cursor, Codex, ~/.agents/skills):

curl -fsSL https://raw.githubusercontent.com/aka-kika/akakika-skills/main/install.sh | bash

From a clone:

git clone https://github.com/aka-kika/akakika-skills
cd akakika-skills
./install.sh

Useful flags:

./install.sh --dry-run                 # show what would happen
./install.sh --copy                    # copy instead of symlink
./install.sh --targets claude,grok     # only some agents
./install.sh --dir ~/src/akakika-skills

Symlink installs track the clone: later updates are just git -C ~/Projects/akakika-skills pull (re-run ./install.sh only when new skill names appear). Existing skill folders with the same name are moved aside under ~/.skills-backup/ before linking.

Install one skill by hand

Every skill is a self-contained folder with a SKILL.md (Markdown + a little YAML). Drop the folder wherever your agent loads skills:

AgentWhere it goes
Claude CodeCopy into ~/.claude/skills/ (global) or .claude/skills/ (per-project), then invoke it by name.
CodexCopy into your project and reference it from AGENTS.md, or paste the SKILL.md body into context.
CursorCopy into .cursor/skills/ (or your rules folder) and reference it.
Anything elseOpen the SKILL.md and paste the part you need. It's just Markdown.
# grab one skill
git clone https://github.com/aka-kika/akakika-skills
cp -R akakika-skills/skills/apple-hig/apple-hig-command-palette ~/.claude/skills/

The skills

Project intelligence

Decide what deserves to exist, understand what already does, and keep agents from drifting.

SkillWhat it does
new-project-gateA pre-build gate that kills bad ideas cheaply — six checkpoints, an agent lens and a human lens, and a GO / CUT / KILL verdict before the editor opens.
project-worth-my-timeBuild-vs-buy verdict engine — should you build this, or does it already exist? Weighs effort, alternatives, and your time.
explain-new-projectExplains an unfamiliar codebase in plain language, written for non-technical and self-taught builders.
project-catch-upA "what changed in my stack" research brief — dependency drift, breaking changes, and news, with severity labels.
project-workflowRouter that orchestrates explain / catch-up / worth-my-time with smart skip rules.
between-runs-auditA read-only checkpoint between coding-agent runs — classifies everything KEEP / DELAY / REMOVE and ends with one unambiguous next action.
old-project-auditKEEP / MERGE / ARCHIVE for tools that already exist — never limbo. Includes a non-negotiable footgun check for stale pipelines pointing at live data.

Design

Tokens, color, and taste — the system the apps are built on.

SkillWhat it does
kika-design-systemA real, production design system — color/type/spacing tokens, components, and a SwiftUI reference implementation. Adopt it or adapt it.
color-principlesSeven principles for premium, calm, accessible color — a review lens for any UI, website, or app.

Apple HIG

Native Apple design, to spec — the patterns that make an app feel like it belongs.

SkillWhat it does
apple-hig-command-paletteA full ⌘K command palette: scoring/ranking, action registry, and accessibility.
apple-hig-sidebarsNavigationSplitView sidebars — two- vs three-column, grouping, and keeping navigation calm.
apple-hig-toolbarsToolbars — per-screen action maps, one clear primary action, and placement discipline.
apple-hig-inspectorsInspector panels done right — when to use one, the item model, and per-type detail views.
apple-hig-macos-window-layoutThe macOS window shell — sizing, and when to use a sheet vs a window vs a popover.
apple-hig-typographyThe text-style scale — sizes, weights, monospaced digits, and line-length caps for legible Apple typography.
apple-hig-sf-symbolsChoosing and using SF Symbols — a nav/action/status vocabulary, variants, and rendering modes.
apple-hig-search-filteringSearch, filter, and sort — a clean separation of the three, with a working filter function.
apple-hig-empty-statesEmpty, first-run, and no-result states — six typed cases built on ContentUnavailableView.
apple-hig-feedback-statusFeedback, status, progress, and alerts — a real state vocabulary and no fake percentages.
apple-hig-settingsSettings/Preferences — scenes, AppStorage vs Keychain, and SMAppService.

Swift & macOS

Implementation — from MenuBarExtra to notarization, the plumbing that has to be exactly right.

SkillWhat it does
macos-menubar-swiftuiMenu-bar apps w

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/ai-agents/agent-starter-pack/SKILL.md5.5 KBupstream ↗
    ---
    name: agent-starter-pack
    description: Use when creating a new project folder, starter pack, app scaffold, or agent-ready workspace — AGENTS.md, README, TASKS, DECISIONS, PROMPTS, an idempotent bootstrap script, and starter-pack modes.
    ---
    
    # Agent Starter Pack
    
    Scaffold a new project so any coding agent can pick it up immediately: structure, memory, tasks, prompts, and clear instructions. Never overwrite user files or copy secrets by default.
    
    ## When to use
    
    Use this skill when creating a new project folder, starter pack, app scaffold, or agent-ready workspace.
    
    Use for project starter apps, bootstrap scripts, universal project templates, and new agent project setup.
    
    ## Core rule
    
    ```
    Every new project should start with structure, memory, tasks, prompts, and clear instructions for the coding agent.
    ```
    
    ## When to use this skill
    
    Use when the user says:
    
    - new project starter
    - create project folder
    - starter pack
    - bootstrap project
    - [AGENTS.md](http://AGENTS.md)
    - universal project template
    - create app folder structure
    - project scaffold
    - agent-ready project
    
    ## When not to use this skill
    
    Do not use this skill for:
    
    - Existing project refactors unless user asks to add starter files
    - UI design only
    - GitHub workflow only
    - Full app generation without asking for target platform/framework when unknown
    
    ## Default folder structure
    
    ```
    ProjectName/
      AGENTS.md
      README.md
      TASKS.md
      DECISIONS.md
      PROMPTS.md
      CHANGELOG.md
      .env.example
      .gitignore
      docs/
        product-brief.md
        architecture.md
        ui-notes.md
      prompts/
        build.md
        review.md
        polish.md
      skills/
      src/
      assets/
      tests/
    ```
    
    ## Minimal project files
    
    ### [AGENTS.md](http://AGENTS.md)
    
    ```markdown
    # AGENTS.md
    
    ## Project Goal
    Describe what this project is building.
    
    ## Rules for the agent
    - Read README.md first.
    - Check TASKS.md before coding.
    - Record major decisions in DECISIONS.md.
    - Keep changes small and explain them.
    - Run available tests or explain why not.
    
    ## Current Stack
    - Platform:
    - Language:
    - Framework:
    - Package manager:
    
    ## Output Requirements
    After each task, report:
    1. Files changed
    2. What changed
    3. How to test
    4. Known risks
    ```
    
    ### [README.md](http://README.md)
    
    ```markdown
    # Project Name
    
    ## Purpose
    
    ## Features
    
    ## Setup
    
    ## Run
    
    ## Test
    
    ## Notes
    ```
    
    ### [TASKS.md](http://TASKS.md)
    
    ```markdown
    # TASKS.md
    
    ## Now
    - [ ] Define first task
    
    ## Next
    - [ ] Add next task
    
    ## Later
    - [ ] Add future idea
    
    ## Done
    - [ ] Completed work
    ```
    
    ### [DECISIONS.md](http://DECISIONS.md)
    
    ```markdown
    # DECISIONS.md
    
    ## Decision Log
    
    ### YYYY-MM-DD — Decision title
    Context:
    Decision:
    Reason:
    Tradeoffs:
    ```
    
    ### [PROMPTS.md](http://PROMPTS.md)
    
    ```markdown
    # PROMPTS.md
    
    ## Build Prompt
    
    ## Review Prompt
    
    ## Polish Prompt
    ```
    
    ## Starter pack modes
    
    ```
    minimal = AGENTS, README, TASKS, DECISIONS, PROMPTS
    app = minimal + src, assets, tests, docs
    swiftui = app + Xcode notes, app architecture docs
    web = app + package scripts and frontend docs
    ai = app + prompts, skills, memory, evals
    ```
    
    ## Bootstrap script behavior
    
    If creating a script:
    
    ```
    Input: target folder path
    Optional: include .env.local or not
    Creates missing folders
    Copies template files
    Does not overwrite without confirmation
    Prints next steps
    ```
    
    ## Safe bootstrap rules
    
    - Never overwrite user files silently.
    - Ask before copying secrets.
    - Default to `.env.example`, not `.env.local`.
    - Print created files.
    - Print skipped files.
    - Make the script idempotent.
    
    ## Shell script pattern
    
    ```bash
    #!/usr/bin/env bash
    set -euo pipefail
    
    target="${1:-}"
    
    if [[ -z "$target" ]]; then
      echo "Usage: ./bootstrap.sh /path/to/new-project"
      exit 1
    fi
    
    mkdir -p "$target"/{docs,prompts,skills,src,assets,tests}
    
    touch "$target/README.md"
    touch "$target/TASKS.md"
    touch "$target/DECISIONS.md"
    touch "$target/PROMPTS.md"
    touch "$target/.env.example"
    
    echo "Created project starter at: $target"
    ```
    
    ## Menu bar project starter app behavior
    
    For a menu bar starter app:
    
    ```
    Settings:
    - Default projects folder
    - Starter files to include
    - Skill folders to include
    - Default AGENTS.md template
    - Git init toggle
    - Open in Finder toggle
    - Open in editor toggle
    
    Create flow:
    - Project name
    - Location
    - Starter pack mode
    - Selected skills
    - Create
    ```
    
    ## Quality checklist
    
    ```
    [ ] Project has AGENTS.md
    [ ] Project has README.md
    [ ] Project has TASKS.md
    [ ] Project has DECISIONS.md
    [ ] Project has PROMPTS.md
    [ ] Secrets are not copied by default
    [ ] Existing files are not overwritten silently
    [ ] Folder structure matches project type
    [ ] Next steps are printed
    [ ] The agent can understand what to do next
    ```
    
    ## Common mistakes
    
    ```
    Starting projects with only source files
    No AGENTS.md
    No task list
    No decision log
    Copying .env.local by default
    Overwriting files silently
    Too many folders with no purpose
    No README setup instructions
    ```
    
    ## Prompt template
    
    Drop this into any coding agent (Claude Code, Codex, Cursor, …) to apply the skill:
    
    ```
    Use the agent-starter-pack skill to create an agent-ready project starter.
    
    Rules:
    - Create a clear project folder structure.
    - Include AGENTS.md, README.md, TASKS.md, DECISIONS.md, PROMPTS.md, and .env.example.
    - Add docs/, prompts/, skills/, src/, assets/, and tests/ as appropriate.
    - Do not overwrite existing files silently.
    - Do not copy secrets by default.
    - Make bootstrap scripts idempotent.
    - Print created and skipped files.
    - Add clear next steps for the user.
    
    After coding:
    1. List created files/folders.
    2. Explain starter pack mode.
    3. Explain overwrite/secrets behavior.
    4. Give manual test steps.
    ```
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/aka-kika-akakika-skills-skills-ai-agents-agent-starter-pack.md

// REPO STATS

12 stars
0 open issues
Last commit: 16d ago