balls

Decompose complex problems into verifiable sub-questions with confidence scoring.

46|2|Updated Jan 18, 2026
One-click install
npx skills add https://github.com/gbasin/balls-mode --skill balls
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: balls
Source: https://github.com/gbasin/balls-mode/tree/main/plugins/balls-mode/skills/balls
Command: npx skills add https://github.com/gbasin/balls-mode --skill balls

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured, multi-step reasoning process for complex questions, breaking them down into verifiable units and assigning confidence scores to each part.

Core Features & Use Cases

  • Decomposition: Breaks down complex queries into smaller, manageable "balls" or sub-questions.
  • Verification: Solves and verifies each sub-question independently.
  • Confidence Scoring: Assigns a confidence score (0.0-1.0) to each sub-question's answer.
  • Synthesis: Combines individual answers, highlighting the weakest link and overall confidence.
  • Use Case: When deciding whether to rewrite a service in a new language, this Skill can break down the decision into factors like performance needs, team expertise, and codebase complexity, providing a reasoned answer with clear uncertainty.

Quick Start

Use the balls skill to determine if this service should be rewritten in Rust.

Frequently Asked Questions about balls

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I break down complex architectural decisions for AI coding assistants?

Decomposing complex architectural decisions involves breaking queries into verifiable units, solving each independently, and assigning confidence scores. This structured reasoning process provides transparent answers with explicit uncertainty tracking for technology choices.

What is decomposed reasoning with confidence scoring for software engineering?

Decomposed reasoning with confidence scoring is a multi-step process that breaks complex problems into manageable sub-questions. It solves each independently, assigns a 0.0-1.0 confidence score, and synthesizes a final answer highlighting the weakest link and overall confidence.

How do I evaluate codebase rewrite decisions like switching to Rust?

Evaluating codebase rewrite decisions requires breaking down factors like performance needs, team expertise, and codebase complexity into sub-questions. Each factor is solved and verified independently with a confidence score before synthesizing a reasoned answer with clear uncertainty.

Can I use confidence scoring to debug complex code review concerns?

Confidence scoring can be applied to debug complex code review concerns by deconstructing the issue into verifiable units. Each unit is solved independently and scored from 0.0 to 1.0, synthesizing a transparent conclusion that highlights the weakest reasoning link.

What are the limitations of decomposed reasoning for AI assistants?

Limitations of decomposed reasoning include reliance on the accuracy of individual sub-question verification and the potential for low overall confidence scores. If any verifiable unit receives a low score, the synthesized final answer explicitly highlights this weak link and uncertainty.

Does decomposed reasoning work for technology selection and architectural choices?

Decomposed reasoning works for technology selection and architectural choices by breaking down complex decisions into factors like performance and team expertise. It solves each factor independently, assigns confidence scores, and synthesizes a final recommendation with tracked uncertainty.