Skills (carson2222)

carson2222/skills

Four skills for OpenCode: design variants, live X data through Grok CLI, memory of past sessions and posts tuned to the X feed.

  • 111 ★ on the repository
  • Last commit
  • Apache-2.0
Skill

Broad access

Why this level

  • The `grok-cli` skill starts Grok CLI with the `--yolo` flag: the subagent runs its tools without confirmation.
  • The `opencode-memory` skill opens local session history, which may hold secrets and private conversations.
All reasons and checks

carson2222/skills

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/carson2222-skills

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • The `grok-cli` skill starts Grok CLI with the `--yolo` flag: the subagent runs its tools without confirmation.
  • The `opencode-memory` skill opens local session history, which may hold secrets and private conversations.

This is third-party code. Review the repository files before installing.

What it does

The set has four skills for OpenCode that install through `npx skills`. `design-exploration` makes several design variants of a component or page, five by default, in different visual directions, and after you choose implements the pick with real data. `x-algorithm` explains how the X For You feed scores posts and helps write and review drafts. `grok-cli` gives the agent a verified command for calling Grok CLI headless for fresh data and deep X searches. `opencode-memory` reads local OpenCode history: sessions, conversations, plans and projects, through `sqlite3` in read-only mode.

Who it is for. OpenCode users who need quick design exploration, live X data and search through past sessions.

Good fit when

  • A new screen needs several visual directions and choosing is easier by eye in a browser.
  • You want to know what people write about a product update on X over the last day.
  • A draft X post is checked for filters that quietly remove a post from the feed.
  • You returned to a project and look for an earlier plan or decision from an old OpenCode session.

Not a fit when

  • You need one finished design without choosing: the skill builds several variants first.
  • You work in another agent and `opencode-memory` reads only the OpenCode database.
  • Grok CLI is not installed, or its tools must not be approved automatically.
  • Session history contains secrets the agent must not see.

Example request

Make five variants of the pricing page in different visual directions and implement the chosen one with real project data.

Limitations

The skills are written for OpenCode: `opencode-memory` reads `~/.local/share/opencode/` on macOS and Linux. `grok-cli` needs an installed and authenticated Grok CLI and `jq`, and starts Grok with the `--yolo` flag, meaning its tools are not confirmed. For `design-exploration` the author recommends Claude Opus 4.6 with a high thinking budget and advises against Codex for frontend work. The `x-algorithm` advice rests on the open-sourced X feed code released in May 2026.

How to disable. Delete the folders of unneeded skills from the OpenCode skills directory or reinstall only the ones you need. The OpenCode history that `opencode-memory` read stays in place.

FAQ

How do I install skills from carson2222/skills?

Each installs with its own command: `npx skills add carson2222/skills --skill design-exploration -g -y`. Replace the name after `--skill` with `grok-cli`, `opencode-memory` or `x-algorithm`.

Why does grok-cli use --disallowed-tools web_fetch?

It forces Grok to search through live `web_search`. Without the flag the model loops on `web_fetch` for X and news links, and the call dies on a timeout.

What does opencode-memory read?

OpenCode sessions, conversations, plans, projects and prompt history. The skill finds the database with `opencode db path`, opens SQLite read-only and writes nothing.

How many variants does design-exploration make?

Five by default, and the number can be set in the request. In a new project the variants define the design system itself, and in an existing app they change layout within the current tokens.

What is x-algorithm based on?

On the open-sourced implementation of the xAI For You recommendation system released in May 2026: the ranker, candidate retrieval and content quality classifiers.

Discussion

No questions or reviews yet.

Skills

The xskill CLI gathers sanitized session trajectories from Claude Code, Codex and OpenCode and grows a shared skill library.

CLIExtended access129Repository stars

Agents, skills and templates for structured AI development in OpenCode, Codex and Claude Code: docs, plans, review, checkpoints

WorkflowExtended access61Repository stars

CLI turns functions and commands from source code into verified skill records with provenance and retrieval metadata.

CLIExtended access110Repository stars

A catalog of nearly two hundred skills: code delivery, review, debugging, AI governance, product work and agent coordination.

SkillMinimal access174Repository stars

A Rust tool with its own window: scans Codex, Claude Code and Gemini CLI skills, checks risks and enables or disables them

CLIExtended access202Repository stars

A universal loader for Anthropic-format skills (SKILL.md) in any coding agent: install, sync and load on demand

CLIExtended access10.8KRepository stars

Comparison with similar tools

Cards that share the main search query, and how they differ.

ToolOfficialRepository starsMain difference
Skills (carson2222) (this card)no111
Frontend Design (Ilm-Alan)no166fixes aesthetics through eight anchors in CSS tokens; design-exploration builds five different variants and implements the chosen one
Grok Buildyes27,745an xAI coding agent for the terminal; the grok-cli skill in this set teaches OpenCode to call Grok CLI for fresh data

README in short

The README opens with a table of four skills, followed by a collapsed section for each with an install command, the problem it solves, contents and requirements. The set is licensed under Apache 2.0.

README badge

Original SKILL.md

---
name: design-exploration
description: Generates multiple distinct design variants of a component or page, each with a completely different visual direction, then implements the chosen one. Use when the user asks to redesign, restyle, explore design options, create multiple visual directions, or compare design approaches for any UI element -- components, pages, sections, dashboards, landing pages, or full layouts.
license: Apache-2.0
---

# Design Exploration

Generate N distinct design variants for a given component, page, or section. Each variant takes a fundamentally different visual direction. Present all for comparison, then fully implement the chosen one.

## When to Trigger

### 1. New project
The user is bootstrapping a frontend from scratch. No existing design system -- the variants define it.

### 2. Existing app
The user has an established design language and wants multiple approaches for a new or existing component, section, or page. Every variant must stay consistent with the app's existing patterns and tokens.

### Bypass: Detailed design spec provided
If the user provides exact fonts, colors, hex values, border radii, and specific styling instructions -- skip Phase 2 entirely. This is an implementation request, not an exploration request. Do not suggest alternatives or inject creative direction. Read each target file, preserve all logic, apply exactly the specified changes. Go directly to Phase 3.

## Phase 1: Research

Before designing anything:

1. **Read the existing code** -- understand every component, import, animation, and logic in the target files.
2. **Study the design language** -- globals.css, tailwind config, component library, existing patterns (spacing, colors, typography, card styles).
3. **Identify constraints** -- what must NOT change: data, logic, API calls, routing, state management.
4. **Understand the content model** -- what data is displayed, edge cases (long text, many items, empty states).
5. **Check assets** -- verify images, icons, and assets exist with correct formats (transparency, resolution, aspect ratio). If assets need preprocessing (background removal, format conversion), handle that before building variants on top of them.
6. **Look beyond the brief** -- find data values available in the codebase but not currently displayed, existing assets that could be repurposed, values that could be visualized differently (charts, progress bars, indicators instead of plain text), opportunities for grouping or layering information.

## Phase 2: Generate Variants

Create exactly the number requested (default: 5). Determine mode automatically based on project state -- do not ask.

### Mode A: New Project

No existing design system to follow.

1. **Research broadly** -- search for design approaches across disciplines: product design, editorial, print, architecture, fashion branding, game UI, packaging. Do not rely on memorized style lists.
2. **Analyze context** -- product purpose, audience, intended mood. A trading app has different needs than a portfolio.
3. **If context is insufficient, ask** -- what is the product, who is it for, what feeling should it evoke. Exception: if the user explicitly wants broad exploration, skip this.
4. **Select styles optimal for this project** -- each must be a plausible direction for this exact product, not a showcase of range. Respect explicit style exclusions as hard constraints. Do NOT fall into deterministic patterns of always picking the same style families.
5. **Maximize diversity** -- every variant must differ in spatial thinking, typographic voice, and emotional register. Not "same layout, different colors."

Report a problem