DEV Community: Deduped

Add Claude to your GitHub pull requests with one command in Claude Code

Deduped — Mon, 02 Nov 2026 02:05:13 +0000

Code review is where a lot of small bugs get caught, and where a lot of teams run out of hours. claude-code-action is Anthropic's GitHub Action that lets Claude answer questions and make changes straight from pull request and issue comments. Setting a GitHub App, secrets and a workflow file by hand is fiddly. The README has a quicker route, and it starts inside Claude Code.

What you get

Once installed, you can mention @claude in a PR or issue comment. According to the README, the action can answer questions about code and architecture, review the changes in a PR and suggest improvements, and implement simple fixes, refactors and even new features. It shows progress with checkboxes that update as it works, and it runs on your own GitHub runner. Anthropic API calls go to the provider you choose.

It picks its mode automatically from your workflow context: responding to @claude mentions, issue assignments, or automation with an explicit prompt.

Before you start

You must be a repository admin, because you will install a GitHub App and add secrets.
The quickstart below is only for direct Anthropic API users. If you use Amazon Bedrock, Google Vertex AI or Microsoft Foundry, follow docs/cloud-providers.md in the repo instead.
Coming from v0.x? The repo has a migration guide to v1.0 that simplifies configuration around two inputs, prompt and claude_args.

Step 1: open Claude Code in the repo

cd your-repo
claude

Step 2: run the installer command

Inside Claude Code, run:

/install-github-app

The command walks you through installing the GitHub App and adding the required secrets. Follow the prompts.

Step 3: confirm the setup

Check the repository settings: the GitHub App should be installed, and the API key secret should exist under Actions secrets. Also look for the new workflow file the setup adds, and read it before merging. It defines when Claude is allowed to run.

Step 4: test with a harmless comment

Open a throwaway PR and comment:

@claude explain what the main function in this file does

If Claude replies with a progress checklist and then an answer, you are done. Only then try a real request such as "@claude add a unit test for this edge case".

Tips for staying safe

Treat it like a new contributor. Review its changes before merging, every time.
Keep the permissions in the workflow minimal. The README says additional tools can be enabled through configuration, so enable them one at a time.
Remember that PR text goes to your chosen model provider, so check that fits your code policy.

A prompt you can hand to your agent

If you would rather not click through, give Claude Code this: "Install anthropics/claude-code-action on this repo using /install-github-app, confirm the secrets, then open a test PR comment asking Claude to explain one function."

The step-by-step card is on Deduped: Add Claude to your GitHub repo's pull requests and issues. For more things people do with the terminal agent, see AI use cases for Claude Code and how to explain an unfamiliar codebase with Claude Code.

Source repo: anthropics/claude-code-action.

Want the setup commands for 50 AI repos people actually ship with? Get the free AI Repos That Actually Ship pack: https://dedupedai.com/ship-pack/?utm_source=devto&utm_medium=article&utm_campaign=shippack

Get one email every Monday with the week's hottest AI repos and exactly how to use them: subscribe free at dedupedai.com

Use your Claude, ChatGPT or Gemini subscription in goose, no API key

Deduped — Mon, 02 Nov 2026 02:05:12 +0000

Most AI agents ask for a pay-per-token API key, even when you already pay for Claude, ChatGPT or Gemini every month. That means two bills for the same models. goose, the open source agent now run under the Linux Foundation's Agentic AI Foundation, has a way around it: its README says you can use your existing Claude, ChatGPT or Gemini subscription through ACP providers instead of API keys.

This is the short version of how to set that up, plus what to check before you trust it.

What goose is

goose is a general-purpose agent that runs on your machine. It ships as a native desktop app (macOS, Linux, Windows), a CLI, and an API. It is written in Rust, works with 15+ providers (Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, Bedrock and more), and connects to 70+ extensions through the Model Context Protocol. It is not only for code: research, writing, automation and data analysis are all in scope.

Step 1: install it

Either download the desktop app from the installation page, or install the CLI with the command from the README:

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash

As with any piped script, read it first if you are cautious. It is the official release script from the repo, but it is still a remote script running on your machine.

Step 2: pick the subscription route

Open the ACP providers guide linked from the README (goose-docs.ai, under guides, ACP providers). ACP is the protocol goose uses to talk to a provider that you are already logged into. The idea is that goose drives your existing Claude, ChatGPT or Gemini plan instead of billing API tokens.

Connect the provider you pay for, following the guide for that one. The exact flow differs per provider, so I will not guess at flags here. Use the guide as the source of truth, and check the repo for newer instructions, since this part moves fast.

Step 3: run a small test task

Do not start with a big job. Give goose something short and checkable, for example:

Research three open source tools that do X, and give me a table with name, licence, and last release date.

Confirm two things: the task completes, and your provider's usage page shows the usage against your plan rather than a new API charge. If you see an API charge, you are on the wrong provider entry.

Step 4: switch providers later

Because goose supports many providers, you can swap models without changing how you work. That is the practical win: try Claude for one task, Gemini for the next, or a local Ollama model when you are offline, all from the same interface.

Who this suits

You have a consumer or team plan and no appetite for API billing.
You want one agent UI across several model vendors.
You want an open source, inspectable agent rather than a closed app.

Caveats

Subscription terms are set by each provider. Check that your plan allows this kind of use before you rely on it.
We wrote our walkthrough from the README, not from a test run, so verify each step against the docs.
Extensions give an agent real access to your machine. Add them one at a time.

Where to go next

The full card, with the steps and a ready agent prompt, is on Deduped: Use goose with your existing subscription. If you want other agents that work with the tools you already have, browse AI use cases for Claude Code.

Source repo: aaif-goose/goose.

Get one email every Monday with the week's hottest AI repos and exactly how to use them: subscribe free at dedupedai.com

Let Claude Code or Cursor debug your page in a real Chrome browser

Deduped — Sun, 01 Nov 2026 20:01:59 +0000

When Claude Code or Cursor fixes a front-end bug, it is usually guessing. It reads your source, but it cannot see the page, the console errors or the network calls. The Chrome DevTools MCP server closes that gap: it lets your coding agent control and inspect a live Chrome browser, so it can reproduce a bug, read the real error and check that its fix worked. Here is the setup, using the commands from the README. The short version is on the Deduped use-case page.

What it gives your agent

chrome-devtools-mcp is a Model Context Protocol server that exposes Chrome DevTools to an AI coding assistant such as Claude, Cursor, Copilot or Antigravity. According to the README it does three main things:

Performance insights: records traces with Chrome DevTools and extracts actionable findings.
Advanced browser debugging: analyzes network requests, takes screenshots and reads console messages with source-mapped stack traces.
Reliable automation: uses puppeteer to act in Chrome and waits for the results of each action.

Requirements

Node.js (an LTS version)
Current stable Chrome
npm

Step 1: add the server to your MCP client

Add this config to your MCP client:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    }
  }
}

Using @latest means your client always starts the newest version. The README has per-client instructions for Claude Code, Cursor, VS Code and others in its client configuration guide.

Step 2: run the first prompt

Paste this into your client to check that everything works:

Check the performance of https://developers.chrome.com

Your client should open Chrome and record a performance trace. The browser starts only when the agent first uses a tool that needs it, so connecting alone will not open a window.

Step 3: point it at your own bug

Now give it a real task. For example:

Open http://localhost:3000/checkout, click Pay, and tell me what the console
and network panel show. Then fix the cause and verify it in the browser.

The agent can reproduce the click, read the failing request and the source-mapped stack trace, edit your code, reload and confirm the error is gone. That loop is the whole value: it checks its own work against a real browser instead of assuming.

Optional: use the CLI instead of MCP

The package also ships a chrome-devtools CLI, so you can drive the browser from a terminal or a script without MCP:

npm i chrome-devtools-mcp@latest -g
chrome-devtools navigate_page 1 --url "https://developers.chrome.com"
chrome-devtools take_screenshot 1 --filePath screenshot.png
chrome-devtools stop

Privacy settings worth knowing

The server exposes the content of the browser instance to your MCP client, so avoid sharing sensitive data in that browser. A few details from the README:

Google collects usage statistics by default. Opt out with the --no-usage-statistics flag, for example "args": ["-y", "chrome-devtools-mcp@latest", "--no-usage-statistics"].
Performance tools may send trace URLs to the Google CrUX API to add real-user data. Disable that with --no-performance-crux.
Update checks can be turned off with the CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS environment variable.
Only Google Chrome and Chrome for Testing are officially supported. Other Chromium browsers may work but are not guaranteed.

When to use it

Use it for bugs you can only see in a running page: a layout that breaks at one width, a request that fails only after login, a slow page where you need a trace rather than a hunch. For pure logic bugs a normal test run is faster.

More like this

Compare it with other browser tools on best AI repos for browser automation, or see every Chrome DevTools MCP use case.

Turn any web page into clean markdown for ChatGPT or Claude

Deduped — Sun, 01 Nov 2026 20:00:22 +0000

Paste a web page into ChatGPT or Claude and most of what you send is navigation, cookie banners and script tags. Fetch it with plain requests and a JavaScript-heavy page often comes back nearly empty. Firecrawl solves both: give it a URL and it returns clean markdown of the page's main content, ready for a prompt or a vector store. Here is how to set it up from Python, Node, curl or the CLI, with the commands from the README. The short version lives on the Deduped use-case page.

What Firecrawl does

Firecrawl is an API to search, scrape and interact with the web, built for AI agents. Its scrape endpoint converts any URL to markdown, HTML, screenshots or structured JSON. It handles rotating proxies, rate limits and JavaScript-blocked content, and it can parse PDFs and DOCX files into markdown too.

It is open source under AGPL-3.0 (the SDKs are MIT) and also runs as a hosted service. The examples below use the hosted API, which needs a key from firecrawl.dev. The README links a self-hosting guide if you would rather run it yourself.

Step 1: get a key and keep it out of your code

Sign up at firecrawl.dev to get your API key. It starts with fc-. Put it in an environment variable rather than in a file you commit:

export FIRECRAWL_API_KEY="fc-YOUR_API_KEY"

Step 2: scrape a page to markdown

Python

pip install firecrawl

import os
from firecrawl import Firecrawl

app = Firecrawl(api_key=os.environ["FIRECRAWL_API_KEY"])

doc = app.scrape("https://firecrawl.dev", formats=["markdown"])
print(doc.markdown)

Node.js

npm install firecrawl

import { Firecrawl } from 'firecrawl';

const app = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });

const doc = await app.scrape('https://firecrawl.dev', { formats: ['markdown'] });

curl

curl -X POST 'https://api.firecrawl.dev/v2/scrape' \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
  "url": "firecrawl.dev"
}'

CLI, with only the main content of the page:

firecrawl https://firecrawl.dev --only-main-content

The output is plain markdown: headings, lists and text, without the page chrome. That is what you paste into a prompt or split into chunks for retrieval.

Step 3: go wider when one page is not enough

The same client covers the jobs that usually come next:

# Find URLs on a site, ordered by relevance to a word
result = app.map("https://firecrawl.dev", search="pricing")

# Scrape several URLs at once
job = app.batch_scrape([
    "https://firecrawl.dev",
    "https://docs.firecrawl.dev",
], formats=["markdown"])

# Crawl a docs site (the SDK waits for the job to finish)
docs = app.crawl("https://docs.firecrawl.dev", limit=50)
for d in docs.data:
    print(d.metadata.source_url, d.markdown[:100])

Crawling a whole docs site this way is the fastest route to a knowledge base for a docs chatbot.

Step 4: give Claude Code or Cursor the same power

If you want your coding agent to read current docs instead of guessing from training data, install Firecrawl as a skill and restart the agent:

npx -y firecrawl-cli@latest init --all --browser

Or add it as an MCP server in any MCP client:

{
  "mcpServers": {
    "firecrawl-mcp": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "fc-YOUR_API_KEY"
      }
    }
  }
}

That config holds your key, so keep it out of shared or committed config files.

Caveats

Respect each site's terms and robots rules when you scrape.
Crawls cost credits per page on the hosted service, so set a limit while testing.
The README examples hardcode fc-YOUR_API_KEY; reading it from the environment, as above, is the safer habit.

More like this

Compare Firecrawl with other options on best AI repos for web scraping for LLMs, or see every Firecrawl use case, including giving your coding agent live web access.

Make Claude Code design, plan and test before it writes code

Deduped — Sun, 01 Nov 2026 19:47:31 +0000

Ask Claude Code for a feature and it usually starts typing code in the first reply. Sometimes that works. Often you get a half-guessed design, no tests, and an hour of rework. Superpowers fixes that by giving your coding agent a full development method as a set of skills: it asks what you want first, writes a design you sign off on, turns that into a plan, then builds it task by task with tests and a review after each task. Here is the setup and the workflow, with the real commands from the README. The short version lives on the Deduped use-case page.

What Superpowers is

Superpowers is a set of composable skills plus some starting instructions that make sure your agent uses them. The skills trigger on their own, so you do not call them by hand. When the agent sees you are building something, it steps back and asks what you are really trying to do before it writes anything.

It works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, OpenCode and several other agents. If you use more than one, install it separately for each.

Install it

In Claude Code, install from Anthropic's official plugin marketplace:

/plugin install superpowers@claude-plugins-official

Or register the Superpowers marketplace and install from there:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Other agents, from the same README:

# Gemini CLI
gemini extensions install https://github.com/obra/superpowers

# GitHub Copilot CLI
copilot plugin marketplace add obra/superpowers-marketplace
copilot plugin install superpowers@superpowers-marketplace

In Cursor Agent chat, run /add-plugin superpowers. In Codex CLI, open /plugins, search for Superpowers and select Install Plugin.

A quick check from the README: start a fresh session and send "Let's make a react todo list". A working install triggers brainstorming before any code is written.

The workflow, step by step

You describe a feature in a few sentences, in a git project. Then the skills take over in this order:

brainstorming draws out what you actually want through questions, then plays its understanding back for correction. Small changes get agreed in chat; bigger projects get a written design document.
using-git-worktrees activates after you approve the design. It creates an isolated workspace on a new branch, runs project setup and checks that tests pass before anything changes.
writing-plans breaks the work into bite-sized tasks of 2 to 5 minutes each. Every task has exact file paths, complete code and verification steps.
subagent-driven-development (or executing-plans) runs the plan. The first dispatches a fresh subagent per task with a review after each, which is the most thorough. The second implements every task inline in the current session with one review of the whole branch at the end, which is the cheapest.
test-driven-development enforces red, green, refactor: write a failing test, watch it fail, write minimal code, watch it pass, commit. It deletes code written before tests.
requesting-code-review runs between tasks, reviews against the plan and reports issues by severity. Critical issues block progress.
finishing-a-development-branch verifies tests and gives you the choice to merge, open a PR, keep or discard, then cleans up the worktree.

What you actually do

Your job shrinks to three checkpoints:

Answer the brainstorming questions honestly. This is where vague features turn into a clear spec.
Read the design in the short chunks the agent shows you, and sign off only when it matches what you want.
Check the plan. Every task should list exact file paths and how it will be verified. If one does not, ask for it before you say "go".

Then say "go" and read each code review as it comes back.

A prompt you can paste into any supported agent:

Using the Superpowers skills, take this feature: <feature description>.
Run brainstorming, then writing-plans, then subagent-driven-development
in this project. Show me the design and the plan before any code.
Every plan task must list exact file paths and a verification step.

Caveats

The README says it is not uncommon for the agent to work autonomously for a couple of hours without deviating from the plan. That is the point, and also the risk: whatever is in the approved plan is what gets built. Spend your attention on the design and plan, not on watching the code scroll.

If a session misbehaves (a skill fires when it should not, or the agent ignores its plan), ask the agent to "figure out what went wrong with superpowers in this session". That invokes the diagnosing-superpowers skill, which reads the transcript and reports what happened with evidence.

One more thing worth knowing: the optional visual companion in brainstorming loads a logo from the maintainers' site that includes the Superpowers version. To turn that off, set SUPERPOWERS_DISABLE_TELEMETRY to any true value. It also honors Claude Code's DISABLE_TELEMETRY setting.

More like this

Superpowers is one of several skill packs that change how a coding agent works. Compare it with the others on best coding agent skills, or see every Superpowers use case, including root-cause debugging.

Build a Blender scene from a text prompt with Claude Code

Deduped — Sun, 01 Nov 2026 01:04:05 +0000

Blocking out a scene in Blender by hand means hours of menus and modifiers. MCP for Blender lets Claude Code, Codex or another AI app drive Blender directly: it creates objects, places them, applies materials and checks its own work with renders. The short version is on the Deduped use-case page. Below is the route with the commands from the README.

What you need

Blender installed, an AI app that supports MCP, and macOS or Linux for the one-line installer. This walkthrough comes from the README, not a test run, so check the repo for newer instructions.

One-command setup

curl -LsSf https://www.mcp-for-blender.com/install.sh | sh

If you already have uv, this does the same thing:

uvx mcp-for-blender setup

The setup asks which MCP clients to configure. It adds a blender entry to each and saves a .bak copy of every config it touches, so you can roll back.

Manual route for Claude Code or Codex

If the automatic setup misses your client, add the server yourself:

claude mcp add blender uvx mcp-for-blender
codex mcp add blender -- uvx mcp-for-blender
uvx mcp-for-blender install-addon

The last command installs and enables the Blender addon.

Start the connection

Fully quit and reopen your AI app, then open Blender. The addon starts its server, and the AI app can now see it.

Ask for a scene

Be concrete. A prompt shape that works:

Using ahujasid/mcp-for-blender, build a low-poly campsite at dusk in the open Blender file: create the objects, apply materials, set up a camera and light, then show me renders from two angles and list what you created.

Make it check itself

Ask for multi-angle views or a render after each pass. Models misplace things in 3D often, and a render makes the mistake obvious. Then iterate in plain language: "move the tent left of the fire", "make the sky warmer".

Safety note

The server can run Python inside Blender, so save your file first, and use safe mode if you want to limit what it runs. Do not point it at a project you cannot restore.

For another creative workflow with an agent, see the HyperFrames product video walkthrough.

Sandbox any MCP server in Claude Code with one line

Deduped — Sun, 01 Nov 2026 01:04:04 +0000

An MCP server is a program you hand to your agent and let run on your machine, with your user's permissions. Most are fine. If one is buggy or compromised, it can read your SSH keys or call out to any host. Anthropic's Sandbox Runtime (srt) wraps any process in OS-level file and network limits, no container needed. Here is the setup with the real commands. The short version lives on the Deduped use-case page.

What srt does

srt uses sandbox-exec on macOS and bubblewrap on Linux, plus proxy-based network filtering. It was built for Claude Code and is a beta research preview, so config formats may change. Defaults are strict: no network access, no writes outside the working paths, and reads allowed everywhere unless you deny them.

Install

npm install -g @anthropic-ai/sandbox-runtime

Try it before wiring anything

srt "curl anthropic.com"
srt "curl example.com"
srt "cat ~/.ssh/id_rsa"

With an allowlist containing anthropic.com, the first call succeeds. The second prints "Connection blocked by network allowlist". The third fails with "Operation not permitted". That is the whole idea: the process only gets the holes you poke.

Wrap an MCP server

Your unsandboxed .mcp.json entry probably looks like this:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"]
    }
  }
}

Change the command to srt and move the old command into args:

{
  "mcpServers": {
    "filesystem": {
      "command": "srt",
      "args": ["npx", "-y", "@modelcontextprotocol/server-filesystem"]
    }
  }
}

Set the limits

Create ~/.srt-settings.json:

{
  "filesystem": {
    "denyRead": [],
    "allowWrite": ["."],
    "denyWrite": ["~/sensitive-folder"]
  },
  "network": {
    "allowedDomains": [],
    "deniedDomains": []
  }
}

Writes are allow-only, so allowWrite lists the places the server may write. Reads are deny-then-allow. Network is allow-only: an empty allowedDomains means no network at all, so add the hosts your server really needs.

One gotcha from the README: if the settings file exists but is empty or invalid, srt exits with an error instead of falling back to defaults. That is on purpose, because a silent fallback would drop your deny rules.

Test that it bites

Ask your agent to write a file into the denied folder. You should see an EPERM "operation not permitted" error. If the write succeeds, your config is not being read, so check the path and run srt --debug on a sample command.

srt --debug curl https://example.com
srt --settings /path/to/srt-settings.json npm install

Where it stops

Sandboxing limits what the server can touch, not what it is told to do with data you give it. Keep secrets out of the folders you allow, and keep the allowlist short. Windows support is newer and has documented known limitations, so read that section of the README first.

For another way to cut risk in Claude Code, see the GitHub MCP server walkthrough.

Stop Claude Code from building the same generic landing page

Deduped — Sat, 31 Oct 2026 19:02:24 +0000

Ask Claude for a landing page and you tend to get the same thing: a warm cream background, a terracotta accent, identical rounded cards with soft shadows and an all-caps eyebrow above every heading. The frontend-design skill in Anthropic's example skills repo exists to break that habit. Below is the route with the real commands. The short version is on the Deduped use-case page.

What the skill does

Skills are folders of instructions, scripts and resources that Claude loads when a task calls for them. frontend-design makes Claude commit to a bold aesthetic direction and a reviewed design plan before it writes any UI code. It even lists the generic defaults to avoid.

Install

In Claude Code, register the repo as a plugin marketplace:

/plugin marketplace add anthropics/skills

Then install the example skills, which include frontend-design:

/plugin install example-skills@anthropic-agent-skills

Give it a real brief

Tell Claude the real subject, the audience and the primary job of the page. If the brief leaves the subject out, the skill has Claude propose one and confirm it with you, so you will not get lorem ipsum branding.

Ask for the plan first

Before any code, ask for a design plan:

4 to 6 named hex colors
the typefaces and their roles
a layout concept with ASCII wireframes
the principles that make this page unique

Review the plan

Have Claude check the plan against your brief and rewrite any part that reads like a generic default, saying what changed and why. This one step is where most of the improvement comes from, because it is cheap to change a plan and expensive to change a finished page.

Check the quality floor

The result should be responsive down to mobile, show visible keyboard focus and respect reduced motion. Test each of those yourself before shipping.

A prompt you can paste

Use the frontend-design skill from anthropics/skills to design a landing page for my product. Before writing any code, give me a design plan: 4 to 6 named hex colors, the typefaces and their roles, a layout concept with an ASCII wireframe, and the principles. Review the plan against my brief, revise anything that reads like a generic default and tell me what you changed. Spend the boldness in one place, and keep it responsive down to mobile with visible keyboard focus and reduced motion respected.

Who it is for

A developer or founder who keeps getting the same templated look from generated UI.

Tip

Spend the boldness in one place. A page with one memorable element and a calm everything else usually beats a page where every section shouts.

For another Claude Code design option, see the Taste Skill walkthrough.

Get one email every Monday with the week's hottest AI repos and exactly how to use them: subscribe free at dedupedai.com

Run a full SEO audit on your site from Claude Code

Deduped — Sat, 31 Oct 2026 19:02:23 +0000

A manual SEO audit takes hours and an agency audit costs thousands. Claude SEO is a free plugin for Claude Code that audits any site in roughly 10 to 15 minutes and hands back a prioritized action plan. Here is the route from the README, with the real commands. The short version lives on the Deduped use-case page.

What it checks

The plugin is built from 26 sub-skills and 19 specialist agents, and up to 17 of them work on your site at the same time. It covers:

Technical SEO: crawlability, indexing, sitemaps, robots.txt, redirects, page speed and Core Web Vitals.
Content quality: E-E-A-T, thin pages and topic coverage.
Structured data: finds, validates and writes Schema.org markup.
AI search (GEO): how likely Google AI Overviews, ChatGPT, Perplexity and Gemini are to cite your pages.
Local and e-commerce SEO.

Every recommendation explains why it matters and how you will know it worked.

Install it

Inside Claude Code, register the marketplace and install the plugin:

/plugin marketplace add AgriciDaniel/claude-seo
/plugin install claude-seo@agricidaniel-claude-seo

Set it up

Run setup once. It creates its own Python environment and a headless browser:

/seo setup
/seo doctor

/seo doctor checks readiness, so fix anything it flags before the first audit.

Run the audit

Type /seo to list every command. For a full website audit with parallel agents, give it your URL:

/seo audit https://your-site.example

For a single page use /seo page with the URL. Focused commands exist too, for example /seo technical, /seo content, /seo schema, /seo sitemap, /seo geo and /seo local.

What you get back

Reports come out as Markdown, PDF and JSON, with a prioritized action plan. Work through it from the most important item down, and re-run the specific command after each fix to confirm it moved.

A prompt you can paste

Install Claude SEO from AgriciDaniel/claude-seo, run /seo setup and /seo doctor, then run /seo audit on <my site url>. Give me the top five fixes ranked by impact and how I will know each one worked.

Who it suits

A founder or freelancer who wants a scored audit and a to-do list without audit software, or a consultant who wants real numbers on the first call.

The catch

It runs on your Claude Code plan, so a full audit with many agents uses part of your usage allowance. Start with /seo page on your most important URL if you are on a tight plan.

Get one email every Monday with the week's hottest AI repos and exactly how to use them: subscribe free at dedupedai.com

Install a team of specialist agents into Claude Code

Deduped — Sat, 31 Oct 2026 01:01:53 +0000

Generic prompts give generic answers, and writing a good persona for every role takes hours. Agency Agents is a collection of ready-made specialist agent files (frontend developer, backend architect, DevOps automator and many more) that you can drop into Claude Code. Below is the route from the README, with the real commands. The short version is on the Deduped use-case page.

What you get

Each agent file holds an identity and personality, a core mission and workflow, technical deliverables with code examples, and success metrics. The idea is that you activate the specialist that fits the task instead of re-explaining a role every session.

Fastest install

The README now recommends a native desktop app for macOS, Linux and Windows that browses the roster and installs agents into Claude Code, Cursor, Codex, Gemini CLI and others. On a Mac:

brew install --cask msitarzewski/agency-agents/agency-agents

Prefer the terminal? The scripts install the same agents.

Install with the script

Clone the repo, then list what exists:

./scripts/install.sh --list teams

Install only the divisions you need into Claude Code:

./scripts/install.sh --tool claude-code --division engineering,security

Or install everything for Claude Code:

./scripts/install.sh --tool claude-code

Or copy one division by hand

cp engineering/*.md ~/.claude/agents/

That is all Claude Code needs: the files sit in its agents directory.

Use a specialist

Start a Claude Code session and ask for a role by name. The README's own example:

Hey Claude, activate Frontend Developer mode and help me build a React component

For a feature that spans layers, split the work:

Use the Backend Architect agent to design the API for , then the Frontend Developer agent to build its UI. Summarize what each agent produced.

Switch to the DevOps Automator agent when the task becomes pipelines and deployment.

Other tools

The same repo can generate integration files for other tools. The README lists GitHub Copilot, Gemini CLI, OpenCode, Cursor, Aider, Windsurf, Codex and more. Run the converter, then install:

./scripts/convert.sh
./scripts/install.sh --tool gemini-cli

The Deduped page on using these agents in Cursor or Codex covers that route.

Things to know

Installing every division loads a lot of agent files. Start with engineering and security, and add more only when you use them.
A persona does not replace review. Read what the Backend Architect proposes the way you would read a colleague's design.
Agent files are prompts that shape behavior, so skim one before installing a collection from any repo.

Setup takes about 10 minutes: one install command, one session, one named specialist. If you want to trim what your agent loads, compare with the Deduped page on installing a startup MVP runbook team.

Make Claude Code build a landing page with real art direction

Deduped — Sat, 31 Oct 2026 01:01:53 +0000

Ask a coding agent for a landing page and you usually get the same page: a gradient hero, three feature cards, a stock-looking footer. Taste Skill is an Agent Skill that tries to fix that. Per its README, it gives the agent an art direction, real credited pictures, and a way to check its own work in a real browser. Here is the Claude Code route, using the commands from the README. The short version lives on the Deduped use-case page.

What it does

The README describes a build that runs in steps. The skill reads your brief and lists what only your client has (product, story, materials). A script then deals three art directions, you pick one, and the agent builds with real photographs found in open archives. The skill credits those photos. Finally it checks the result in a real browser at three widths and fixes the top problems for up to three rounds.

The point is that the page is built from your specifics, not an average of every landing page the model has seen.

Requirements

Per the README, the skill runs its scripts with Node 22 or newer and needs an installed Chrome, Edge or Chromium. It installs nothing else and needs no API keys. Finding pictures needs network access.

Install in Claude Code

Run these inside Claude Code:

/plugin marketplace add Leonxlnx/taste-skill
/plugin install taste-skill@taste-skill

The skill is namespaced under taste-skill:, so it will not collide with your other skills. /plugin update upgrades it later.

If you prefer the skills CLI, the README gives this instead:

npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"

Codex users have a plugin route too:

codex plugin marketplace add Leonxlnx/taste-skill
codex plugin add taste-skill@taste-skill

Start a new Codex session afterwards so the skill loads.

Write a brief that has something in it

The skill works best when the brief lists what only this client has. Compare:

Weak: "A landing page for a coffee roaster."
Better: "A landing page for a two-person roaster in Lisbon. They roast on a 1970s Probat, sell only single-origin beans from three farms, and ship on Mondays. Customers are mostly returning subscribers."

The second brief gives the skill real material for the art direction step and for choosing pictures.

Run it

Prompt Claude Code something like:

Use the taste-skill design-taste-frontend skill to build a landing page for from this brief: . Pick one of the dealt directions, credit every photo, and show me the screenshots from each check round.

Then do three things:

Look at the three directions it deals and choose one on purpose rather than accepting the first.
Open the credits file it produces and confirm the photos have open licenses.
Read the screenshots from each check round, so you see what it found and fixed.

Things to know

A build takes roughly 30 to 45 minutes and a few hundred thousand tokens, so check your plan limits before starting.
It builds from a brief, so vague input gives vague output.
You still review the page. A browser check at three widths catches layout problems, not whether the copy is true.
Pin to a version you trust if you rely on it for client work, and run /plugin update deliberately.

If your agent keeps handing you generic pages, this is a 45 minute experiment: install the plugin, write one specific brief, and compare the result with what you got before. For other ways to steer Claude Code, see the Deduped page on stopping Claude Code from overengineering.

Search all your past Claude Code sessions with MemPalace

Deduped — Fri, 30 Oct 2026 19:13:06 +0000

Every Claude Code session starts from zero. You explain why you picked GraphQL, and three days later you explain it again. Worse, the MemPalace README warns that Claude Code sessions expire in 30 days unless you wire auto-save hooks. MemPalace is a local-first memory tool that stores your conversation history verbatim and lets you search it in plain language. Here is the CLI route, with the commands from the README. The short version is on the Deduped use-case page.

What it is

MemPalace stores conversation text as it was written. It does not summarize or paraphrase. The index is structured: people and projects become wings, topics become rooms, and original content lives in drawers, so you can scope a search instead of querying one flat pile. The default backend is ChromaDB, and per the README nothing leaves your machine unless you opt in.

Install

The README recommends installing the CLI in an isolated environment, which avoids PEP 668 errors on Debian, Ubuntu and Homebrew Pythons:

uv tool install mempalace
# or
pipx install mempalace

There is also an agent-guided route. Install the skills, then ask your coding agent to set it up:

npx skills add MemPalace/mempalace

The setup skill detects your system, installs the package, configures MCP and asks whether you want a private local palace or a shared one. Installing the skill alone does not install the CLI or MCP server, so let the agent finish the guided setup.

Mine your project and your sessions

Point it at a project:

mempalace init ~/projects/myapp
mempalace mine ~/projects/myapp

Then mine your Claude Code transcripts:

mempalace mine ~/.claude/projects/ --mode convos

Use --wing to scope each project to its own wing, so a search about one app does not pull in another.

Search and wake up

Ask the question you keep re-explaining:

mempalace search "why did we switch to GraphQL"

You get the original conversation back, not a summary of it. To start a new session with context loaded, run:

mempalace wake-up

To check how well organized the palace is, run the read-only audit:

mempalace audit

Make Claude use it

A search tool only helps if the agent runs it. A prompt you can put in your first message or in CLAUDE.md:

Before answering any question about past decisions in this repo, run mempalace search with the question and quote the matching original text. Do not delete or move any transcript files.

For other ways to give Claude Code memory, compare with claude-mem, which summarizes instead of storing verbatim, or the Deduped page on Docker MCP memory for Claude Code.

Things to know

The palace holds your full transcripts verbatim. Keep it on a disk you trust, and be careful with anything containing secrets.
Back up your existing JSONL transcripts before relying on any of this. The README links a Claude Code retention checklist for the auto-save hooks.
Mining a large history takes time, so start with one project.
Verbatim storage means bigger storage than summaries, which is the trade for exact recall.

If your sessions keep losing context, this is a 20 minute fix: install, mine, search, and add one line to your rules file.

Get one email every Monday with the week's hottest AI repos and exactly how to use them: subscribe free at dedupedai.com