Skip to content
Back to search

skills

Agent skills I use in my own coding workflow, published for others to reuse.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/carson2222--skills/badge.svg)](/listings/carson2222--skills)

HTML

<a href="/listings/carson2222--skills"><img src="/api/listings/carson2222--skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add carson2222/skills --skill design-exploration -g -y

Or browse on [skills.sh](https://skills.sh/carson2222/skills/design-exploration).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 180 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Skills
  2. Agent skills for [OpenCode](https://opencode.ai). Install with [`npx skills`](https://skills.sh) or clone directly.
  3. ## Available Skills
  4. | Skill | Description |
  5. |---|---|
  6. | [design-exploration](design-exploration/) | Generates multiple design variants with different visual directions, then implements the chosen one |
  7. | [grok-cli](grok-cli/) | Use the Grok CLI for fresh, real-time info — deep X/Twitter digging and live news/web research, with a verified one-command recipe |
  8. | [opencode-memory](opencode-memory/) | Read-only access to local OpenCode history — sessions, plans, conversations, and project context |
  9. | [x-algorithm](x-algorithm/) | Write X posts that the For You algorithm rewards — grounded in the open-sourced ranker, retrieval, and content classifiers |
  10. ---
  11. <details>
  12. <summary><h2>design-exploration</h2></summary>
  13. Generates multiple distinct design variants of a component or page, each with a completely different visual direction, then implements the chosen one.
  14. ### Install
  15. ```bash
  16. npx skills add carson2222/skills --skill design-exploration -g -y
  17. ```
  18. Or browse on [skills.sh](https://skills.sh/carson2222/skills/design-exploration).
  19. ### What it does
  20. Give it a component, page, or section and it produces N variants (default 5), each taking a fundamentally different visual direction. You compare them in the browser, pick one, and it implements the final version with real data.
  21. Works in two modes:
  22. - **New project** — no design system yet, variants define one. Each gets its own fonts, colors, layout philosophy.
  23. - **Existing app** — design system already exists. Variants explore different layouts and compositions while staying consistent with your tokens and patterns.
  24. ### What models work best
  25. **Claude Opus 4.6** with high thinking budget covers ~95% of runs. Gemini can produce solid UI too. Open source models (GLM5, MiniMax, Kimi K2.5) sometimes surprise you but are less predictable. Codex is not recommended for frontend design.
  26. ### How to get good results
  27. This is not a "run it and pray" skill. Output quality scales directly with context. Before running:
  28. - What matters to you? Professional? Playful? Dark and moody?
  29. - Who is this for? What vibe are you going for?
  30. - Drop assets (images, logos, icons) in the project folder with descriptive filenames.
  31. Talk to it like you'd talk to a designer. The more you give it, the better it gets.
  32. </details>
  33. <details>
  34. <summary><h2>grok-cli</h2></summary>
  35. Use the [Grok CLI](https://x.ai/cli) as a sub-agent to pull fresh, real-time information the model doesn't have — especially digging deep into X/Twitter and breaking news.
  36. ### Install
  37. ```bash
  38. npx skills add carson2222/skills --skill grok-cli -g -y
  39. ```
  40. Or browse on [skills.sh](https://skills.sh/carson2222/skills/grok-cli).
  41. ### The problem
  42. When you tell the agent to "use grok", it burns several turns rediscovering whether grok exists, what flags it takes, and how to call it — then often hangs. The default model loops on `web_fetch` against X/news URLs and never returns, so the call dies on a timeout with nothing to show.
  43. This skill hands the agent one verified command and tells it to run it immediately. No discovery dance, no hung calls.
  44. ### What it does
  45. Teaches the agent to call `grok -p` headless for live data, with the exact recipe that actually works:
  46. - `-m grok-build` — the Grok model, not the composer model
  47. - `--yolo` — auto-approve tools (required headless)
  48. - `--disallowed-tools web_fetch` — force xAI live `web_search`; the key fix that stops the fetch loop
  49. - `--max-turns` cap + JSON output parsed with `jq`
  50. Includes ready-to-paste templates for deep X/Twitter digging (specific posts, @handles, URLs, sentiment, influential accounts) and live news research, plus follow-up calls in the same grok session.
  51. ### Requirements
  52. - The `grok` CLI installed and authenticated (`curl -fsSL https://x.ai/cli/install.sh | bash`, then `grok login`)
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 84 on GitHub
  53. - `jq` on PATH (pre-installed on most macOS/Linux)
  54. ### Triggers
  55. "use grok", "ask grok", "dig into twitter/x", "what's X saying about…", "latest/fresh on…", or autonomously whenever current real-time data beyond the training cutoff would help.
  56. </details>
  57. <details>
  58. <summary><h2>opencode-memory</h2></summary>
  59. Lightweight, read-only access to your local OpenCode history. No injection, no bloat — the agent can look things up when it would help.
  60. ### Install
  61. ```bash
  62. npx skills add carson2222/skills --skill opencode-memory -g -y
  63. ```
  64. Or browse on [skills.sh](https://skills.sh/carson2222/skills/opencode-memory).
  65. ### The problem
  66. Every "memory" plugin out there injects context everywhere, bloating every request. Most of the time you don't need history. But when you do — resuming a project, referencing a past decision, debugging something that came up before — the agent should be able to check on its own without you having to explain where OpenCode stores things.
  67. Without this skill, getting the agent to browse local OpenCode data requires precise wording and a lot of luck. It tries Claude, Codex, random paths, and gives up. This skill solves that by teaching the agent exactly where to look and how to query it.
  68. ### What it covers
  69. - **Sessions** — list, filter by project, search by title
  70. - **Messages** — read full conversations from any session
  71. - **Search** — full-text search across all past conversations
  72. - **Plans** — list and read saved plans
  73. - **Projects** — see all tracked projects with session counts
  74. - **Prompt history** — recent prompts you've typed
  75. ### How it works
  76. The skill teaches the agent the OpenCode storage model and provides ready-to-use `sqlite3` queries. It uses `opencode db path` when available to find the active database, then opens SQLite read-only. No scripts, no external tools — just `sqlite3` (available on every Mac/Linux) and bash. The SKILL.md contains the database paths, schema, and copy-paste query templates for every common operation.
  77. The agent will auto-trigger when:
  78. - You reference something done before ("last time", "that plan we made")
  79. - You're resuming work on a project
  80. - You ask about history, plans, or past sessions
  81. - It suspects prior context would help
  82. ### Requirements
  83. - `sqlite3` CLI (pre-installed on macOS and most Linux)
  84. - OpenCode must have been used at least once (creates the database)
  85. - macOS/Linux (reads `~/.local/share/opencode/`, respects `XDG_DATA_HOME`)
  86. </details>
  87. <details>
  88. <summary><h2>x-algorithm</h2></summary>
  89. Write X (Twitter) posts that the For You algorithm actually rewards. Derived directly from the open-sourced recommendation system — the Grok-based transformer ranker, Phoenix retrieval, Thunder in-network store, and Grox content-understanding pipeline.
  90. ### Install
  91. ```bash
  92. npx skills add carson2222/skills --skill x-algorithm -g -y
  93. ```
  94. Or browse on [skills.sh](https://skills.sh/carson2222/skills/x-algorithm).
  95. ### What it does
  96. Teaches the agent the actual scoring mechanics of the X For You feed so it can write, review, and debug posts. Covers the 19 predicted engagement actions and their weights, hard filters that silently kill posts, out-of-network retrieval mechanics, author diversity decay, content quality classifiers (VLM banger screen, spam detection), and the engagement caching window.
  97. Use it when you want to:
  98. - Write a post optimized for a specific goal (reach, replies, follows, shares)
  99. - Review or rewrite an existing draft with algorithm-aware feedback
  100. - Diagnose why a post underperformed
  101. - Plan a content strategy grounded in how distribution actually works
  102. ### What's inside
  103. - Full breakdown of the scoring formula (positive + negative action weights)
  104. - Pre-post checklist derived from the actual pipeline
  105. - "Why did this flop?" diagnostic sequence
  106. - Anti-patterns the algorithm punishes
  107. - Myth-busting section for X folklore
  108. ### Source
  109. Based on the [X For You Feed Algorithm](https://github.com/xai-org/x-algorithm) open source release (May 2026).
  110. </details>
  111. ---
  112. ## License
  113. Apache 2.0. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.