Agent skill

Pivot Engine

by MaxKmet in MaxKmet/idea-validation-agents

Generates structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder constraints.

MITAuto-check passed

Install Pivot Engine

skills CLI
$ npx skills add MaxKmet/idea-validation-agents --skill pivot-engine -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install MaxKmet/idea-validation-agents pivot-engine --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/MaxKmet/idea-validation-agents.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/pivot-engine .claude/skills/pivot-engine && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pivot-engine
GitHub stars
474
Token cost
~4.7k tokens
SKILL.md length
1,799 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
MIT

At a glance

Generates structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder constraints.

  • Works in 9 steps: Load and assess weakness landscape → Map weak dimensions to pivot types → Generate pivot options using… → …
  • SKILL.md covers Purpose, Input, Pivot Types and Minimum Viable Pivot Criteria, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Pivot Engine is an agent skill from MaxKmet/idea-validation-agents. Generates structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder constraints. Includes scoring simulation, minimum viable pivot criteria, effort estimation, and indie buildability filtering.

Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It works with Reddit and TikTok. The repository describes itself as: AI agents that act as your personal venture analyst - from startup idea brainstorming to full validation and go-to-market strategy. Built for developers who'd rather validate in… The licence is MIT.

Example prompts

  • “Use the pivot-engine skill to generate structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder…”
  • “/pivot-engine”

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Load and assess weakness landscape
  2. Map weak dimensions to pivot types
  3. Generate pivot options using market_insights
  4. Scoring simulation
  5. Effort estimation
  6. Indie buildability filter
  7. Select recommended pivot
  8. pivot_options.json
  9. pivot_report.md

What it can do on your machine

Read from SKILL.md and the folder at commit 3a4c800. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json and markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Pivot Engine loads about 4.7k tokens when it runs. Until then it costs about 64 tokens; SKILL.md has 1,799 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~64
When it runs · the whole SKILL.md, loaded when a task matches
~4.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from MaxKmet/idea-validation-agents at commit 3a4c800, republished under its MIT licence (© MaxKmet). 1,799 words, ~4,691 tokens.

Download SKILL.mdSave it as .claude/skills/pivot-engine/SKILL.md (or your agent's skills folder).
name
pivot-engine
description
Generates structured pivot options for a scored idea based on weak dimensions, market_insights signals, and founder constraints. Includes scoring simulation, minimum viable pivot criteria, effort estimation, and indie buildability filtering.
<!-- version: 0.3.0 | outputs: memory/ideas/<slug>/pivot_options.json + memory/ideas/<slug>/pivot_report.md -->

Skill: pivot-engine

Purpose

When an idea scores poorly in one or more dimensions, generate concrete pivot options rather than abandoning the idea entirely. A pivot is a deliberate change in one variable to improve the weakest dimension — not a complete restart. The best pivots preserve what's already strong while fixing what's broken, and they're grounded in real market signals, not wishful thinking.

Input

  • Idea slug
  • memory/ideas/<slug>/scores.json (current scores — required)
  • memory/ideas/<slug>/weaknesses.json (weak dimensions with root causes — required, run weakness-detection first)
  • memory/ideas/<slug>/idea.md (current concept)
  • memory/ideas/<slug>/competitors.json (positioning gaps, competitor complaints)
  • memory/ideas/<slug>/distribution.json (current channel assessment)
  • memory/ideas/<slug>/pricing.json (current pricing model and WTP)
  • memory/ideas/<slug>/retention.json (current retention assessment)
  • memory/user_profile.md (ICP tier, budget, time, distribution advantages)
  • memory/market_insights/<niche>-*-<YYYY>-<MM>.md (trend data — use all available platform files)
Using Market Insights

Market insights are essential for generating pivots grounded in real demand rather than theory. Extract:

FieldHow it informs pivots
top_signalsIdentify adjacent niches or audience segments with validated demand. A trending subreddit or TikTok hashtag near the idea's space suggests a viable audience pivot target.
trend_velocityIf the current niche is "declining", pivoting within it is futile — pivot to an adjacent rising niche. If "rising-fast", the problem may be execution (distribution, pricing), not the market.
monetization_evidenceIf monetization is weak but market_insights show competitors successfully charging in the space, the issue is pricing model or positioning, not WTP. Pivot the model, not the idea.
Platform narratives (Reddit complaints, TikTok trends, App Store gaps)Source specific pivot targets: underserved segments mentioned in Reddit threads, content angles trending on TikTok, App Store categories with stale top results.

Pivot Types

Pivot typeWhat changesWhat staysWhen to use
Audience narrowingTarget user segmentCore problem and solutionDemand is broad but shallow; CAC too high because targeting is diffuse
Audience expansionBroaden from niche to adjacent segmentCore solution mechanicsMarket is too small (micro-niche verdict); SOM < $10K
Feature simplificationScope and complexityCore value propositionComplexity too high; time-to-MVP exceeds founder capacity
Feature pivotCore feature emphasisTarget audience and problemCurrent feature set doesn't match what users actually want (review mining signals)
Niche pivotProblem space subcategorySolution approachCompetition too high in broad category; narrow to underserved niche
Pricing pivotPricing model or price pointProduct and audienceWTP mismatch; wrong model for usage pattern; competitive pricing gap
Distribution pivotPrimary acquisition channelProduct and audienceCurrent channel is unviable; founder lacks skills/budget for assumed channel
Platform pivotTarget platform (iOS → web, mobile → desktop)Core idea and audienceWrong platform for audience behavior or market dynamics
Monetization pivotRevenue model (B2C → B2C2B, app → content, product → service)Core domain expertiseDirect monetization unviable but the domain has other revenue paths
Problem pivotWhich problem to solveTarget audience and domainAudience is right but the specific pain point is weak; adjacent problem is stronger

Minimum Viable Pivot Criteria

A pivot must be different enough to change the score but similar enough to preserve existing work and insights. Apply the Same Idea Test:

A valid pivot must meet ALL of these:
  1. Changes exactly 1–2 variables from the list above. Changing 3+ variables is a new idea, not a pivot — create a new idea slug instead.
  2. Preserves at least one strong dimension (score ≥ 60 in the original). A pivot that abandons all strengths is a restart.
  3. Has evidence — the pivot direction is supported by at least one concrete signal (market_insights data, competitor gap, user complaint, trend).
  4. Addressable root cause — the weakness it targets has root_cause_type of "addressable" or "situational" in weaknesses.json. Pivots cannot fix structural weaknesses unless the pivot changes the core mechanic (which usually means it's a new idea).
A pivot is NOT valid if:
  • It requires the founder to acquire a skill set they don't have and can't learn in < 4 weeks
  • It targets a completely different audience AND a different problem (that's a new idea)
  • The only evidence is "maybe this would work" with no supporting signal
  • It makes the idea harder to build without a proportional improvement in market viability

Process

Step 1 — Load and assess weakness landscape
  1. Load weaknesses.json. Identify all weak dimensions and their root causes.
  2. Separate weaknesses into:
    • Addressable (root_cause_type = "addressable" or "situational") → these are pivot targets
    • Knowledge gaps (root_cause_type = "knowledge-gap") → these need more research, not a pivot
    • Structural (root_cause_type = "structural") → only fixable by major pivot or new idea
  3. If overall_weakness_severity = "fatal" and all weaknesses are structural, recommend dropping rather than pivoting. Note this in the output.
Step 2 — Map weak dimensions to pivot types

Use this mapping to identify which pivot types are most likely to improve each weak dimension:

Weak dimensionPrimary pivot typesSecondary pivot types
Demand (< 40)Problem pivot, audience narrowingNiche pivot
Competition (< 40)Niche pivot, audience narrowingFeature pivot, platform pivot
Monetization (< 40)Pricing pivot, monetization pivotAudience narrowing (higher-WTP segment)
Distribution (< 40)Distribution pivot, platform pivotAudience narrowing (more reachable segment)
Retention (< 40)Feature pivot, feature simplificationProblem pivot (pick a stickier problem)
Founder-Market Fit (< 40)Niche pivot (toward founder's domain), feature simplificationPlatform pivot (to founder's strongest platform)

If multiple dimensions are weak, prioritize the one with the lowest score AND an addressable root cause.

Step 3 — Generate pivot options using market_insights

For each applicable pivot type (from Step 2), generate a concrete option:

  1. Pull evidence from market_insights:

    • For audience pivots: look for specific user segments mentioned in Reddit discussions or TikTok content
    • For niche pivots: identify adjacent niches with rising trend_velocity
    • For distribution pivots: check which channels show actual activity for the niche in market_insights
    • For pricing pivots: reference monetization_evidence and competitor pricing from competitors.json
  2. Be specific, not generic:

    • Bad: "Narrow the audience"
    • Good: "Target freelance designers who use Figma (150K+ active in r/FigmaDesign) instead of all designers. This segment has higher WTP ($8–12/mo based on competitor pricing), active Reddit communities for organic distribution, and specific pain points around invoice management that existing tools ignore."
  3. Generate 2–3 options, ranked by expected impact. Each option must pass the Minimum Viable Pivot Criteria.

Step 4 — Scoring simulation

For each pivot option, simulate the expected score change by projecting how each dimension would shift. This gives the orchestrator enough information to decide whether a full re-score is warranted.

Show full SKILL.md (770 more words)Show less
Simulation method

For the dimension(s) the pivot targets, estimate the new score range based on:

  • The pivot direction and its evidence strength
  • Category benchmarks from the rubrics in idea-scoring
  • What the market_insights data suggests about the pivot target

For dimensions the pivot doesn't target, assume they remain unchanged unless there's a clear secondary effect:

  • Audience narrowing typically improves Distribution (+5 to +15) but may reduce Demand (-5 to -10) and Market Size
  • Feature simplification typically improves Founder-Market Fit (+10 to +20) but may reduce Retention (-5 to -10) if features drove stickiness
  • Pricing pivots can affect Distribution (freemium → more installs) and Retention (subscription → commitment)
Projected score calculation
projected_score = sum of (projected_dimension_scores × weights) × projected_floor_penalty

Use the same weights and floor penalty logic from idea-scoring. This is an estimate — the actual re-score (step 4 of the pivot-optimization workflow) will be definitive.

Report as a range: projected_score_range: { low: X, high: Y }.

Step 5 — Effort estimation

Each pivot has an execution cost. Estimate it relative to the founder's tier:

Effort levelDefinitionTypical timeline
LowCan be done in a weekend. Changes copy, positioning, pricing, or targeting — no code changes.1–3 days
MediumRequires feature changes or new content. Some development work.1–3 weeks
HighSignificant rebuild. New core feature, new platform, or new audience requiring fresh research.1–3 months
Tier adjustment on effort
Founder tierAdjust
BeginnerUpgrade effort by one level (what's "medium" for a builder is "high" for a beginner)
BuilderNo adjustment
GrowthDowngrade effort by one level (what's "medium" for a builder is "low" for growth)

A pivot with "high" effort for the founder's tier should be flagged as risky — the time investment may not be justified unless the projected score improvement is substantial (≥ 20 points).

Step 6 — Indie buildability filter

Before finalizing, verify each pivot option passes these constraints:

ConstraintFails if
Solo buildablePivot requires a team (e.g., marketplace requiring both supply and demand side simultaneously)
Budget feasiblePivot requires spend exceeding founder's budget tier (e.g., "run paid social" for a Bootstrap founder)
Time feasiblePivot requires > 3 months of work for the founder's tier
Skill feasiblePivot requires skills the founder doesn't have and can't learn in 4 weeks (e.g., "build an ML model" for a no-code beginner)
No enterprise creepPivot moves the idea toward B2B enterprise, custom sales, or long sales cycles — fundamentally not an indie B2C play

If a pivot fails any constraint, either modify it to fit or discard it and note why.

Rank remaining options by: (projected_score_improvement / effort_level) — the best pivot is the one with the highest score impact per unit of effort.

Tie-breakers:

  1. Stronger evidence from market_insights
  2. Lower risk (fewer dimensions negatively affected)
  3. Preserves more of the original idea's strengths

Output

Write two files to memory/ideas/<slug>/:

1. pivot_options.json

Machine-readable structured data for downstream skills (idea-scoring, decision-memo):

json
{
  "original_score": 0,
  "original_verdict": "",
  "triggered_by_weaknesses": [
    {
      "dimension": "",
      "score": 0,
      "root_cause_type": "",
      "root_cause_description": ""
    }
  ],
  "structural_weaknesses_unpivotable": [],
  "pivot_options": [
    {
      "pivot_id": "pivot-1",
      "pivot_type": "",
      "description": "",
      "specific_change": "",
      "evidence": "",
      "evidence_source": "",
      "meets_minimum_viable_pivot": true,
      "scoring_simulation": {
        "dimensions_improved": [
          { "dimension": "", "current": 0, "projected_low": 0, "projected_high": 0 }
        ],
        "dimensions_worsened": [
          { "dimension": "", "current": 0, "projected_low": 0, "projected_high": 0 }
        ],
        "dimensions_unchanged": [],
        "projected_score_range": { "low": 0, "high": 0 },
        "projected_verdict_range": ""
      },
      "effort": {
        "level": "low | medium | high",
        "tier_adjusted_level": "low | medium | high",
        "timeline": "",
        "what_changes": "",
        "what_stays": ""
      },
      "indie_buildability": {
        "passes": true,
        "constraints_checked": ["solo_buildable", "budget_feasible", "time_feasible", "skill_feasible", "no_enterprise_creep"],
        "failed_constraints": []
      },
      "trade_offs": [],
      "variables_changed": 0
    }
  ],
  "recommended_pivot": "",
  "recommended_pivot_rationale": "",
  "drop_recommendation": false,
  "drop_rationale": "",
  "market_insights_sources_used": []
}
2. pivot_report.md

Human-readable pivot brief. This is the document the founder actually reads. Write it after pivot_options.json is complete — source all data from the JSON, don't introduce new judgements.

Structure
markdown
---
idea_slug: <slug>
original_score: <X>
original_verdict: <verdict>
recommended_pivot: <pivot_id>
created_at: <YYYY-MM-DD>
---

# Pivot Report: <Idea Name>

## Why the Original Idea Scored <X>/100

<2–3 sentences. State the root cause of the low score plainly — not a list of every problem, just the one or two structural reasons the idea can't work as-is. Cite specific scores from scores.json (e.g. "Distribution scored 34/100 because…"). No hedging.>

---

## What Can Be Fixed vs. What Can't

**Addressable weaknesses** (pivot targets):
- <dimension>: <1-sentence root cause and why it's fixable>
- ...

**Structural weaknesses** (cannot be pivoted away):
- <dimension>: <1-sentence root cause and why no pivot can fix it>
- ...

<If all weaknesses are structural, state clearly that a pivot is unlikely to rescue this idea and explain why.>

---

## Pivot Options

### Option 1 — <Pivot Type>: <Short Name> · Projected score: <low>–<high>/100 · Effort: <tier_adjusted_level>

**The change:** <1–2 sentences. Be specific about exactly what changes — audience, feature, channel, pricing model, platform. Name concrete details (specific subreddits, competitor pricing, App Store keywords, etc.).>

**Why this works:** <2–3 sentences grounded in evidence. Cite the market_insights signal, competitor gap, or user complaint that supports this direction. Name the source (e.g. "r/FigmaDesign has 150K active members discussing invoice pain", "BookPal's 1-star reviews consistently mention X", "TikTok hashtag #X has 40M views and rising velocity").>

**What stays the same:** <1 sentence. What existing work and strengths are preserved.>

**Score projection:**
| Dimension | Current | Projected |
|---|---|---|
| <dimension> | <current>/100 | <low>–<high>/100 |
| <dimension (worsened)> | <current>/100 | <low>–<high>/100 |
| ... | ... | unchanged |

**Trade-offs:** <1–2 sentences. What this pivot gives up. Be honest — every pivot has a cost.>

**Effort:** <What specifically needs to change — code, copy, positioning, research. Timeline.>

---

### Option 2 — <Pivot Type>: <Short Name> · Projected score: <low>–<high>/100 · Effort: <tier_adjusted_level>

<Same structure as Option 1.>

---

### Option 3 — <Pivot Type>: <Short Name> · Projected score: <low>–<high>/100 · Effort: <tier_adjusted_level> *(optional)*

<Same structure as Option 1. Include only if a genuinely distinct third option exists.>

---

## Recommendation

**Go with Option <N> — <Short Name>.**

<3–4 sentences. State why this option has the best impact-to-effort ratio. Reference the scoring simulation. Name the one thing that makes this pivot more credible than the alternatives (the market signal, the competitor gap, the distribution advantage). End with a specific first action the founder should take this week.>

**If this pivot also scores below 50:** <1 sentence — what that means and what to do (drop, major rethink, or new idea slug).>

---

## What to Do First

<1–3 concrete steps, ordered. Each step should be doable within a week. No vague advice — name the specific subreddit, pricing change, App Store keyword, or feature to cut. If a RAT experiment makes sense before committing to the pivot, define it here: ≤2 weeks, ≤$100, pass/fail criteria.>
Writing rules for pivot_report.md
  1. Every claim cites a source. Name the market_insights file, competitor data point, or dimension score behind every assertion. "Demand is weak" is not a claim — "Demand scored 36/100 because search volume for 'invoice app for freelancers' is 2,400/mo, below the 10K threshold for a viable indie SOM" is.
  2. Options must be meaningfully distinct. Don't generate three variations of the same audience pivot. Each option should change a different variable.
  3. Score projections must be ranges, not false precision. 62–71/100 is honest. 67/100 implies certainty the model doesn't have.
  4. The recommendation must pick one. Not "it depends" — commit to the best option and explain why.
  5. Total length: ~500–800 words. Cut anything that doesn't help the founder decide. This is a decision brief, not a research report.

Notes

  • If overall_weakness_severity = "fatal" and all weaknesses are structural, set drop_recommendation = true and explain why no pivot can save this idea. Still generate 1 option as a "Hail Mary" if the founder wants to try, but be honest about the odds.
  • When generating niche pivots, always check competitors.json for positioning_gaps — an identified gap with evidence is the strongest pivot foundation.
  • Pivot options that combine two small changes (e.g., audience narrowing + pricing change) are allowed as a single option if both changes are "low" effort. Call this out as a compound pivot and flag the higher risk.
  • The pivot_id field is used by idea-scoring to link re-scores in pivot_scores.json back to the specific option.
  • If market_insights files are past their stale_after date, note that pivot evidence may be outdated and recommend refreshing trend analysis before committing to a pivot direction.

© MaxKmet, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/pivot-engine of MaxKmet/idea-validation-agents.

Open the folder on GitHubat commit 3a4c800

Compare with similar skills

Pivot Engine next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Pivot Engine compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Pivot Engine this skillMaxKmet/idea-validation-agents474—~4.7kAutomated safety check: PassMIT
Platform Arbitrageacogood/diffmode_free163—~2.5kAutomated safety check: PassApache-2.0
Social Media Monitornexscope-ai/eCommerce-Skills1.1k—~584Automated safety check: PassMIT
Last30daysmvanhorn/last30days-skill64k—~7.8kAutomated safety check: NotesMIT
Scrapecreators APIScrapeCreators/social-media-research-skills3.3k1 repos~4kAutomated safety check: NotesMIT
Last30days CnJesseovo/last30days-skill-cn1.9k—~2.4kAutomated safety check: NotesMIT

Similar skills

  • Platform Arbitrage

    acogood/diffmode_free

    Platform arbitrage audit for a founder's product — a Diffmode growth-tactics think-tank research stage (prompt TT-DG-003).

    163 GitHub stars~2.5k tokensUpdated 1 mo ago
    Productivity & AutomationAuto-check passed
  • Social Media Monitor

    nexscope-ai/eCommerce-Skills

    Monitor social media mentions, trends, and competitor activity for e-commerce brands.

    1.1k GitHub stars~584 tokensUpdated 1 mo ago
    Sales & SupportAuto-check passed
  • Last30days

    mvanhorn/last30days-skill

    Research what people actually say about any topic in the last 30 days.

    64k GitHub stars~7.8k tokensUpdated today
    Research & ScienceAuto-check: notes
  • Scrapecreators API

    ScrapeCreators/social-media-research-skills

    Scrape and extract public data from 27+ social media platforms using the ScrapeCreators REST API.

    3.3k GitHub starsUsed in 1 repo~4k tokens
    Backend & APIsAuto-check: notes
  • Last30days Cn

    Jesseovo/last30days-skill-cn

    Research what Chinese internet users actually said in the last 30 days across Weibo, Xiaohongshu (RED), Bilibili, Zhihu, Douyin, WeChat public accounts, Baidu and Toutiao: engagement-weighted…

    1.9k GitHub stars~2.4k tokensUpdated yesterday
    Productivity & AutomationAuto-check: notes
  • Paid Ads Audit

    AgriciDaniel/claude-ads

    Runs a source-grounded paid advertising audit across up to 12 ad platforms, with parallel platform workers, deterministic scoring and a versioned JSON bundle.

    9.8k GitHub stars~1.5k tokensUpdated today
    Marketing & SEOAuto-check passed

More from MaxKmet/idea-validation-agents

All 15 skills in this repo
  • Cac Modeler

    MaxKmet/idea-validation-agents

    Models LTV, CAC by channel, LTV:CAC ratios, and payback period for an indie developer.

    474 GitHub stars~3.3k tokensUpdated 3 mo ago
    Auto-check passed
  • Competitor Mapper

    MaxKmet/idea-validation-agents

    Maps the full competitive landscape — direct, indirect, substitute, and emerging competitors — with positioning gap analysis, review mining, and marketinsights-calibrated saturation scoring.

    474 GitHub stars~3.3k tokensUpdated 3 mo ago
    Auto-check passed
  • Decision Memo

    MaxKmet/idea-validation-agents

    Writes a concise, human-readable decision brief summarizing the full validation analysis — including score, verdict, RAT experiment, pre-mortem, and tier-appropriate next actions.

    474 GitHub stars~2k tokensUpdated 3 mo ago
    Auto-check passed
  • Desire Evaluator

    MaxKmet/idea-validation-agents

    Scores the strength of core human desire motivations (survival, status, belonging, control, curiosity) for a given app idea to predict user pull and retention potential.

    474 GitHub stars~551 tokensUpdated 3 mo ago
    Auto-check passed
  • Distribution Analysis

    MaxKmet/idea-validation-agents

    Evaluates organic reach potential, paid feasibility, platform distribution advantages, creator economy fit, and founder edge for a B2C app idea.

    474 GitHub stars~3.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Idea Scoring

    MaxKmet/idea-validation-agents

    Aggregates all dimension scores into a final idea score (0–100) and issues a verdict.

    474 GitHub stars~3.2k tokensUpdated 3 mo ago
    Auto-check passed

Works with

Questions about Pivot Engine

What does Pivot Engine do?

Generates structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder constraints. Pivot Engine is an agent skill from MaxKmet/idea-validation-agents. Generates structured pivot options for a scored idea based on weak dimensions, marketinsights signals, and founder constraints.

How do I install Pivot Engine in Claude Code?

Run `npx skills add MaxKmet/idea-validation-agents --skill pivot-engine -a claude-code`. Or copy the skill folder (skills/pivot-engine in MaxKmet/idea-validation-agents) into .claude/skills/pivot-engine in your project. Claude Code loads it when a task matches its description.

How do I install Pivot Engine in Codex?

Run `npx skills add MaxKmet/idea-validation-agents --skill pivot-engine -a codex`. Or copy the skill folder (skills/pivot-engine in MaxKmet/idea-validation-agents) into .agents/skills/pivot-engine in your project. Codex loads it when a task matches its description.

Can I use Pivot Engine in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add MaxKmet/idea-validation-agents --skill pivot-engine -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pivot-engine, .gemini/skills/pivot-engine, .github/skills/pivot-engine and .opencode/skills/pivot-engine in your project.

What does Pivot Engine need to run?

SKILL.md names no scripts, command-line tools or credentials: Pivot Engine is instructions for the agent only.

Does Pivot Engine access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Pivot Engine safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Pivot Engine use?

Pivot Engine is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Pivot Engine use?

About 4.7k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Pivot Engine?

Skills that share tags, products or a category with Pivot Engine: Platform Arbitrage (acogood/diffmode_free, 163 stars), Social Media Monitor (nexscope-ai/eCommerce-Skills, 1.1k stars), Last30days (mvanhorn/last30days-skill, 64k stars) and Scrapecreators API (ScrapeCreators/social-media-research-skills, 3.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Pivot Engine?

MaxKmet (a GitHub user) maintains it in MaxKmet/idea-validation-agents, which has 474 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on June 16, 2026.

Source: MaxKmet/idea-validation-agents on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.