Ask Questions If Underspecified

Ask Questions If Underspecified is a community skill for improving AI assistant behavior by asking clarifying questions when requests are ambiguous, covering ambiguity detection, clarification prompts, assumption handling, context gathering, and structured question generation for underspecified tasks.

What Is This?

Overview

Ask Questions If Underspecified provides patterns for building AI-assisted workflows that detect ambiguous requirements and ask targeted questions before proceeding. It covers ambiguity detection that identifies missing information, conflicting requirements, and assumptions that need validation, clarification prompts that generate focused questions to resolve specific ambiguities, assumption handling that explicitly states assumptions when asking questions is not possible, context gathering that collects relevant background information for informed decision making, and structured question generation that produces categorized questions with suggested options. The skill enables AI workflows that seek clarity rather than guessing.

Who Should Use This

This skill serves AI application developers building assistants that handle ambiguous user requests, prompt engineers designing system prompts for reliable AI behavior, and teams building AI tools that interact with non-technical users.

Why Use It?

Problems It Solves

AI assistants that guess at ambiguous requirements often produce incorrect or unwanted results. Users provide incomplete specifications and expect the system to ask for missing details. Silent assumptions lead to work that must be redone when assumptions are wrong. Generic clarifying questions waste time without narrowing the ambiguity.

Core Highlights

Ambiguity detector identifies gaps and conflicts in user requirements. Question generator creates targeted questions with suggested answer options. Assumption tracker lists explicit assumptions when proceeding without full clarity. Context analyzer evaluates existing information to avoid redundant questions.

How to Use It?

Basic Usage

// Ambiguity detection system
interface Ambiguity {
  type: 'missing' | 'conflict'
    | 'vague';
  field: string;
  description: string;
  suggestedQuestion: string;
  options?: string[];
}

function detectAmbiguities(
  request: string,
  context: Record<
    string, unknown>
): Ambiguity[] {
  const ambiguities:
    Ambiguity[] = [];

  // Check for missing scope
  if (!context.targetPlatform)
  {
    ambiguities.push({
      type: 'missing',
      field: 'platform',
      description:
        'Target platform'
        + ' not specified',
      suggestedQuestion:
        'Which platform'
        + ' should this'
        + ' target?',
      options: [
        'Web', 'iOS',
        'Android',
        'Cross-platform'],
    });
  }

  // Check for vague terms
  const vagueTerms = [
    'fast', 'good',
    'simple', 'better'];
  for (const term
      of vagueTerms) {
    if (request.toLowerCase()
        .includes(term)) {
      ambiguities.push({
        type: 'vague',
        field: term,
        description:
          `"${term}" is`
          + ' subjective',
        suggestedQuestion:
          `What does "${term}"`
          + ' mean in this'
          + ' context?',
      });
    }
  }
  return ambiguities;
}

Real-World Examples

// Structured question flow
interface ClarificationFlow {
  questions: Question[];
  assumptions: Assumption[];
  canProceed: boolean;
}

interface Question {
  priority: 'blocking'
    | 'important'
    | 'optional';
  category: string;
  question: string;
  options?: string[];
  defaultOption?: string;
}

function buildClarification(
  ambiguities: Ambiguity[]
): ClarificationFlow {
  const blocking =
    ambiguities.filter(
      (a) => a.type ===
        'missing');
  const optional =
    ambiguities.filter(
      (a) => a.type ===
        'vague');

  return {
    questions: [
      ...blocking.map(
        (a) => ({
          priority:
            'blocking' as const,
          category: a.field,
          question:
            a.suggestedQuestion,
          options: a.options,
        })),
      ...optional.map(
        (a) => ({
          priority:
            'optional' as const,
          category: a.field,
          question:
            a.suggestedQuestion,
        })),
    ],
    assumptions:
      ambiguities
        .filter((a) =>
          a.type ===
            'conflict')
        .map((a) => ({
          field: a.field,
          assumed:
            a.description,
        })),
    canProceed:
      blocking.length === 0,
  };
}

Advanced Tips

Limit clarifying questions to the three most important ambiguities to avoid overwhelming users with too many questions. Provide default options for each question so users can quickly accept reasonable defaults. Track which questions users answer versus skip to refine question priority over time.

When to Use It?

Use Cases

Build a code generation assistant that asks for target framework and language before generating. Create a task management bot that clarifies priority, deadline, and assignee when tasks are underspecified. Design a requirements gathering flow that detects missing acceptance criteria.

Related Topics

Prompt engineering, AI assistants, requirements gathering, ambiguity detection, and user experience.

Important Notes

Requirements

Natural language processing for detecting ambiguous terms and missing fields. Question template library for common ambiguity patterns. User interface for presenting questions with selectable options.

Usage Recommendations

Do: ask specific questions with suggested options rather than open-ended prompts. State assumptions explicitly when proceeding without full information. Prioritize blocking questions that prevent proceeding over nice-to-have clarifications.

Don't: ask more than three clarifying questions in a single interaction. Repeat questions that the user has already answered in the conversation. Block all progress on optional ambiguities when reasonable defaults exist.

Limitations

Ambiguity detection depends on pattern matching and may miss domain-specific ambiguities. Users may find repeated clarification questions frustrating if not well-targeted. Context from previous interactions is lost between sessions without persistent memory.