DEV Community: dadev

How to Check If ChatGPT Recommends Your Business

dadev — Sun, 09 Aug 2026 00:00:00 +0000

Short answer

Run the same buyer questions, then separate mentions, recommendations, and citations.

Write five to ten non-branded questions a qualified buyer could ask, including the buyer type, problem, location, and constraints that affect the choice. Run the same set in a clean session across the AI products that matter to you. Save the complete answer, model, date, companies named, recommendation position, description, and visible sources. Repeat the test on a fixed schedule. One answer is an observation; repeated tests create a baseline. If you want me to prepare that baseline, request a free AI Visibility Snapshot.

01 · When to pay attention

The test becomes useful when it reflects an actual buying decision.

A founder ranks well in Google but cannot find the company in unbranded ChatGPT recommendations.
A sales or marketing team wants to know which competitors AI assistants shortlist for high-intent questions.
The company is mentioned, but the answer describes its category, audience, location, or service incorrectly.
A guide is cited without the company being recommended, or a directory is cited instead of the company website.
The team is considering AI-visibility software but has not yet defined which buyer questions deserve monitoring.
Content, technical SEO, PR, and profile work are happening, but nobody can connect those activities to a repeatable AI-answer test.

02 · Working method

Measure the buyer question and the evidence trail, not whether the model can repeat your homepage.

Business owners are asking why strong Google visibility does not automatically become an AI recommendation. The measurement problem comes first: a branded prompt is too easy, a single screenshot is too unstable, and one percentage hides the difference between being known, cited, and selected.

Start with real buyer questions

A useful prompt names the buyer or company type, the problem, a meaningful constraint, and the decision. For example: ‘We run a 15-person US software company. Which type of consultant should we hire to find repetitive workflows worth automating first?’ That is more diagnostic than ‘best AI consultant’ because it gives the answer system a real comparison to make. Build a small set across discovery, evaluation, and risk. Keep branded questions in a separate diagnostic group so they do not inflate non-branded visibility.

Control what you can repeat

Use a clean or logged-out session when the product allows it. Put location and business context in the prompt instead of relying on hidden personalization. Keep the prompt text stable, record the product and date, and repeat important questions more than once. Model updates, browsing behaviour, session history, location, and phrasing can change an answer. A screenshot proves what happened once; a fixed method lets you compare what happens over time.

Record the answer before reducing it to a score

For each run, save whether the business was named, whether it was recommended, where it appeared in the shortlist, how it was described, which URLs were cited, and which competitors appeared instead. Read the underlying answers. A 40% mention rate can hide a category error in every mention, while a low rate may be less urgent when no competitor appears consistently either. Keep the evidence available beside any aggregate score.

Compare evidence, not wording

When a competitor appears, inspect what an answer can verify about both companies. Check crawlability, the clarity of core pages, first-party proof such as named work and methods, legitimate third-party corroboration, and coverage of the buyer question itself. Do not copy a competitor’s paragraph or manufacture mentions. The useful question is which missing evidence makes the competitor easier to retrieve, understand, or trust for that specific decision.

Turn the finding into one next action

Fix the clearest evidence gap before publishing another general article. That may mean removing a crawler block, clarifying who a service is for, adding verifiable proof, creating the missing comparison or implementation page, improving internal links, or earning a legitimate third-party reference. Record the change and rerun the same prompt set later. The measurement is only valuable when it changes a decision.

03 · Comparison

Track these outcomes separately before creating a visibility score.

A single AI answer can cite your page, mention your company, and still recommend somebody else. These are different observations and they lead to different fixes.

Outcome	What to record	What it tells you
Mention	Whether the answer names the business and whether the description is accurate.	The system can associate the company with some part of the question, but a mention is not necessarily preference or intent.
Recommendation	Whether the company is first, shortlisted, mentioned in passing, or absent.	The answer treats the business as a plausible choice for the buyer’s stated situation.
Citation	Every visible URL attached to the answer, including company, directory, editorial, and community sources.	Which retrieved pages visibly support the response. A cited guide does not guarantee the author’s service will be recommended.
Competitor evidence	The companies selected instead and the pages or third-party sources that support them.	The actual comparison set and the evidence gap worth investigating, rather than the competitors named in an internal strategy deck.

Practical sequence

Build a 30-minute AI Visibility Snapshot in six steps.

### Write three high-intent questions

Choose questions that could precede a sale. Include the US market, company size, use case, or other constraint only when it genuinely changes the answer.
### Run each question in two AI products

Use the exact same wording in clean sessions. Save the complete answers rather than copying only the sentence that names a company.
### Separate presence from preference

Mark your business as absent, mentioned, recommended, or cited. Record description accuracy and shortlist position separately.
### List competitors and sources

Capture every recommended company and visible URL. Note whether support comes from owned pages, directories, reviews, publishers, communities, or another source type.
### Choose one evidence gap

Compare the strongest competitor with your business and select the smallest justified fix. Do not turn the snapshot into a long backlog of speculative tactics.
### Rerun on a fixed schedule

Weekly or monthly is enough for many smaller companies. Keep the core prompt set stable, date each change, and treat answer variation as part of the measurement.

What the first snapshot should produce

The result should be a decision, not a vanity badge.

A useful one-page snapshot shows where the company appears, where it does not, which competitors are selected, which sources support those answers, and the clearest next action. Start manually before buying a platform. Software becomes worthwhile when several markets, products, competitors, and more than about 20 important questions make the repeated work difficult to maintain. The tool should automate a measurement system you understand; it should not decide which customer questions matter. Request the free AI Visibility Snapshot if you want the baseline, competitor evidence, and first action prepared for your company.

Official guidance and public questions

The method uses product guidance for implementation and Reddit only as a demand signal.

Questions about checking ChatGPT business recommendations.

How can I check whether ChatGPT recommends my business?

Create five to ten buyer questions that do not name your company, run the same questions in a clean ChatGPT session, and record whether the business is absent, mentioned, recommended, or cited. Save the competitors and visible sources, then repeat the fixed test on a schedule.

Why does ChatGPT recommend competitors when my business ranks higher on Google?

A Google ranking and an AI recommendation are different observations. An AI answer may use multiple searches, sources, and contextual constraints. Compare the owned pages and independent evidence supporting each competitor instead of assuming one Google position should transfer directly.

Does schema make ChatGPT recommend a business?

No schema type guarantees a recommendation. Accurate structured data can help a system interpret a page, but it cannot replace crawlability, clear positioning, useful content, real proof, and corroborating sources.

How often should a small company test AI visibility?

Weekly or monthly is sufficient for many smaller companies. Use the same core questions, location assumptions, products, and scoring rules so the results remain comparable. Run extra tests after a meaningful site, content, product, or market change.

Should I pay for AI-visibility tracking software?

Start manually so you understand which buyer questions and evidence matter. A platform becomes useful when the prompt set, models, markets, and competitor comparisons are too repetitive for a reliable manual process. Do not buy a dashboard before defining the decisions it must support.

Can I pay to be recommended by ChatGPT?

You cannot buy a guaranteed organic recommendation. Paid placements and organic answers should be measured separately. Focus on making accurate public evidence easy to crawl, understand, and verify, and avoid manufactured mentions or undisclosed paid links.

Claude Code Skills & Agents: Build Custom Slash Commands for Real Work

dadev — Sun, 26 Apr 2026 17:57:06 +0000

Claude Code is powerful out of the box. Skills and subagents turn it into a steadier system: reusable commands, specialised agents, and workflows that scale with your codebase.

What Are Claude Code Skills?

If you've used Claude Code for more than a week, you've probably noticed a pattern: you type the same kinds of instructions over and over. "Review this PR with focus on security." "Deploy to staging and run smoke tests." "Refactor this component using the patterns from our design system."

Skills solve this. A skill is a reusable slash command that gives Claude specific instructions for a task. Instead of typing a paragraph every time you want Claude to do something, you type /deploy or /review-pr and it knows exactly what to do, how to do it, and what standards to follow.

Think of skills as project runbooks for Claude: markdown files, version-controlled alongside your code, and shared across the team. They follow the Agent Skills open standard, which means the pattern can travel beyond Claude Code.

This matters because the biggest productivity drain with AI coding assistants isn't the AI's capability. It's the context you have to provide every single time. Skills eliminate that friction entirely.

::callout
Key takeaway: Skills are reusable slash commands stored as markdown files. They encode your team's standards, workflows, and context so you don't have to repeat yourself. Type /deploy instead of explaining your deployment process every time.
::

Anatomy of a Skill

Every skill lives in a SKILL.md file. It has two parts: YAML frontmatter that tells Claude when and how to use the skill, and markdown content with the actual instructions Claude follows when the skill is invoked.

You can store skills in two places. Global skills go in ~/.claude/skills/ and are available in every project. Project skills go in .claude/skills/ within your repository and are shared with anyone who clones the repo.

The Frontmatter

The frontmatter is where you configure how the skill behaves. The name field sets the slash command name. The description tells Claude (and your team) what the skill does. The invocation field controls when the skill triggers — user means it only runs when explicitly called, while auto lets Claude invoke it when it detects a matching situation.

The agent field is where things get interesting. You can specify which subagent configuration to use — built-in agents like Explore or Plan, or any custom subagent you've defined in .claude/agents/. This lets you create skills that delegate to specialized agents optimized for specific tasks.

The Instructions

Below the frontmatter, you write plain markdown instructions. These are injected as Claude's system prompt when the skill runs. You can include step-by-step procedures, code patterns to follow, validation checks, and references to project files.

The power here is specificity. A generic instruction like "review this code" produces generic results. A skill that says "check for SQL injection in any raw query, verify all user inputs pass through our sanitization middleware, flag any use of eval() or Function(), and cross-reference against our OWASP checklist at docs/security.md" produces consistently excellent results.

Built-in Skills Worth Knowing

Claude Code ships with a set of bundled skills that are available in every session. These are worth learning before you start building your own, because they cover the most common workflows and serve as excellent templates.

/commit

Analyzes staged changes, drafts a commit message following your repo's conventions, and creates the commit. It reads recent commit history to match your style. Sounds simple, but it eliminates the context switch between coding and committing, and it produces consistently better commit messages than most developers write under time pressure.

/simplify

Reviews recently changed code for reuse opportunities, quality issues, and efficiency improvements. This is the skill I run after every significant implementation — it catches the abstractions you missed and the edge cases you forgot while focused on making the happy path work.

/loop

Runs a prompt or slash command on a recurring interval. You can set a fixed interval like /loop 5m /deploy-check or let Claude self-pace. This is how you build monitoring workflows — watching a build, polling for deployment status, or periodically checking test results while you work on something else.

/review-pr

Fetches a pull request, analyzes every commit, checks for security issues, tests coverage gaps, and provides structured feedback. Combine this with project-specific rules in your CLAUDE.md and you get code review that enforces your team's standards automatically.

Building Your Own Skills

The built-in skills are useful, but the real power is in building skills tailored to your project. Here's the framework I use when creating custom skills for teams.

Step 1 — Identify the Repetition

Look at your last 20 Claude Code conversations. What instructions did you type more than twice? What context did you keep providing? Those are your skill candidates. Common patterns: deployment procedures, code review checklists, migration steps, component scaffolding, and test writing conventions.

Step 2 — Write the Instructions

Write your skill instructions as if you're briefing a senior developer who just joined the team. They're smart but they don't know your project. Be explicit about file paths, naming conventions, testing requirements, and what "done" looks like. Vague skills produce vague results.

Include references to your project's documentation. If you have a style guide at docs/style.md, tell the skill to read it. If there's a component template at templates/component.vue, point to it. The more grounded your skill is in actual project artifacts, the better the output.

Step 3 — Set the Right Invocation

Use invocation: user for skills that should only run when explicitly called — deployment, database migrations, anything with side effects. Use invocation: auto for skills that should fire when Claude detects a matching pattern — like automatically applying your component naming convention when it sees you creating a new component.

Auto-invoked skills are powerful but use them carefully. A skill that fires when you don't expect it is worse than no skill at all.

Step 4 — Commit and Share

Put project-specific skills in .claude/skills/ and commit them. Now every developer on the team has the same slash commands, the same standards enforcement, and the same workflow shortcuts. This is how you scale AI-assisted development beyond individual productivity — you encode your team's collective intelligence into reusable commands.

"The biggest productivity drain with AI coding assistants isn't the AI's capability. It's the context you have to provide every single time. Skills eliminate that friction entirely."

Agents and Subagents

Skills tell Claude what to do. Agents control how it does it. Claude Code's agent system lets you spawn specialized subagents — isolated instances that handle specific parts of a task with their own tools, context, and instructions.

The built-in agents cover the most common patterns. Explore is optimized for codebase navigation — fast file searching, pattern matching, and understanding project structure. Plan is a software architect agent that designs implementation strategies, identifies critical files, and considers trade-offs before you write any code. The general-purpose agent handles everything else.

But the real power is in custom agents. You define them in .claude/agents/ with their own system prompts, tool access, and behavioral constraints. A security-review agent that only has read access and focuses exclusively on vulnerability patterns. A migration agent that understands your database schema and ORM conventions. A documentation agent that reads your code and generates docs matching your existing style.

Why Subagents Matter

Subagents aren't just about parallelism. They're about context isolation. When you ask Claude to do ten things in one conversation, context bleeds between tasks. The code review influences the refactoring. The deployment check changes how it writes tests.

Subagents solve this by running in isolation. Each one gets a clean context window, focused instructions, and only the tools it needs. The results flow back to the main conversation, but the work happens in a controlled environment. This is the same principle behind microservices — bounded contexts produce better results than monolithic processes.

A skill can specify agent: my-custom-agent in its frontmatter, and now your slash command delegates to a specialized agent. /security-scan spawns your security agent. /plan-feature spawns your architecture agent. The skill provides the instructions; the agent provides the execution environment.

Real-World Skill Patterns

Here are the skill patterns I've found most valuable across different projects. These aren't hypothetical — they're running in production codebases right now.

Component Scaffolding

A skill that creates new components following your exact project conventions. It reads your existing component templates, applies your naming patterns, sets up the test file structure, and adds the component to your barrel exports. What used to be 15 minutes of boilerplate becomes /new-component Button.

Database Migration Validator

Before running any migration, this skill checks for destructive changes, verifies rollback scripts exist, validates that the migration is compatible with zero-downtime deployment, and tests it against a schema snapshot. It catches the migration that drops a column you're still reading from in production — before it reaches staging.

Release Notes Generator

Reads the git log since the last tag, categorizes changes by type (feature, fix, chore), pulls PR descriptions for context, and generates release notes in your team's format. Some teams want changelogs. Others want Slack-friendly summaries. The skill encodes whatever format your team uses.

Incident Response Runbook

When something breaks at 2 AM, the last thing you want is to remember the exact sequence of diagnostic commands. This skill takes an error description, checks logs, identifies the likely service, runs your standard diagnostics, and produces a structured incident report — all from /incident "API returning 503 on /users endpoint".

The Agent Skills Open Standard

Claude Code skills follow the Agent Skills open standard. This is worth understanding because it means your investment in writing skills isn't locked into a single tool. The same SKILL.md files work across compatible AI tools — your skills are portable.

Claude Code extends the standard with additional features like invocation control, subagent execution, and dynamic context injection. But the base format is interoperable. If you switch tools or use multiple AI assistants across your team, your skills library travels with you.

This is also why skills belong in your repository, not in a personal config. They're project artifacts just like your CI configuration, your linting rules, and your testing standards. They codify how your team works — and they should evolve alongside your code.

The teams I work with who get the most out of Claude Code share one trait: they treat their .claude/ directory as seriously as their src/ directory. Skills are code. Version them. Review them. Iterate on them. The compound returns are enormous.

Sources and Further Reading

Skills plug directly into the broader stack of AI automations for business: research agents, outreach pipelines, and support triage workflows. If you are building these systems for a team and want a partner who treats them as infrastructure, start with the AI automation service.