Architect Screenshot Synthesizer

Synthesizes UI, interaction, and business analysis results into unified, deduplicated development task lists with logical module grouping.

When to Use This Agent

Choose this agent when you need to:

• Combine outputs from UI, interaction, and business analyzer agents into a single coherent feature list without duplication
• Generate implementation-agnostic development task breakdowns organized by functional module with clear hierarchy
• Produce prioritized task lists that translate visual analysis findings into actionable work items for development teams

Consider alternatives when:

• You have only one analysis source and need simple task extraction rather than multi-source synthesis and deduplication
• Your goal is to review an existing task list for quality rather than generate one from analysis inputs (use the reviewer agent)

Quick Start

Configuration

Copy
name: architect-screenshot-synthesizer
type: agent
category: ui-analysis

Example Invocation

Copy
claude agent:invoke architect-screenshot-synthesizer "Synthesize the three analysis JSONs into a development task list for the CRM application"

Example Output

CRM Application Development Task List

Project Overview:
  Customer relationship management platform with contact
  management, deal pipeline tracking, activity logging,
  and reporting dashboards.

Task Breakdown:

  1. Contact Management (14 tasks)
     - Contact CRUD operations
       - [ ] Create contact with name, email, phone, company
       - [ ] Display contact list with search and filters
       - [ ] Edit contact details inline
       - [ ] Archive contact with confirmation dialog
     - Contact Organization
       - [ ] Tag contacts with custom labels
       - [ ] Group contacts by company association
       ...

  2. Deal Pipeline (11 tasks)
     ...

  3. Activity Tracking (8 tasks)
     ...

Feature Summary:
  Total modules: 5
  Total features: 18
  Total tasks: 47

Implementation Notes:
  - Contact Management and Deal Pipeline share the
    Company entity; implement Company module first
  - Reporting depends on all other modules for data

Core Concepts

Synthesis Process Overview

Aspect	Details
Cross-Reference	Match UI components to business functions, link interactions to features, identify coverage gaps between analyses
Deduplication	Merge overlapping findings where UI, interaction, and business analyzers identified the same capability differently
Feature Consolidation	Group related items into coherent features with module-feature-subtask hierarchy and business value priority
Task Generation	Convert consolidated features into implementation-agnostic development tasks with verifiable acceptance criteria
Dependency Mapping	Identify shared entities, prerequisite modules, and suggested implementation sequencing across the task list

Synthesis Pipeline Architecture

┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│  UI Analysis │  │  Interaction │  │  Business     │
│  JSON        │  │  Analysis    │  │  Analysis     │
│              │  │  JSON        │  │  JSON         │
│  Components  │  │  User flows  │  │  Modules      │
│  Layout      │  │  Actions     │  │  Entities     │
│  Patterns    │  │  Transitions │  │  Rules        │
└──────┬───────┘  └──────┬───────┘  └──────┬───────┘
       │                 │                  │
       v                 v                  v
┌──────────────────────────────────────────────────┐
│           Cross-Reference & Deduplicate           │
│  Match component -> function -> interaction       │
│  Remove duplicate feature mentions                │
│  Identify gaps between analyses                   │
└──────────────────────┬───────────────────────────┘
                       v
┌──────────────────────────────────────────────────┐
│         Consolidate & Generate Tasks              │
│  Group into module > feature > subtask            │
│  Prioritize: core > supporting > nice-to-have     │
│  Sequence by dependency order                     │
└──────────────────────┬───────────────────────────┘
                       v
┌──────────────────────────────────────────────────┐
│           Unified Task List Output                │
│  Markdown with checkboxes                         │
│  Module groupings with task counts                │
│  Implementation notes and dependencies            │
└──────────────────────────────────────────────────┘

Configuration

Parameter	Type	Default	Description
priorityScheme	string	"business-value"	Task prioritization method: business-value, implementation-order, or complexity-first
taskGranularity	string	"feature"	Task breakdown level: epic (coarse modules), feature (balanced), or story (fine-grained subtasks)
deduplicationMode	string	"aggressive"	Overlap handling: conservative (keep near-duplicates), aggressive (merge all related items)
outputFormat	string	"markdown"	Task list format: markdown with checkboxes, json structured, or csv for import into project tools
dependencyTracking	boolean	true	Include implementation dependency notes and suggested module sequencing in the output

Best Practices

1. Cross-Reference All Three Analysis Sources Before Generating Tasks - Each analyzer captures a different dimension: UI structure, interaction behavior, and business function. A button visible in UI analysis, described as a click action in interaction analysis, and tied to a business workflow in business analysis represents one feature, not three tasks. Thorough cross-referencing prevents bloated task lists with hidden duplicates.

2. Maintain Implementation Agnosticism in Task Descriptions - Tasks should describe what the system does for users, not which technology implements it. "Display sortable contact list with pagination" is implementation-agnostic. "Create React DataGrid component with server-side sorting" prescribes technology. Agnostic tasks remain valid regardless of framework choices made during development.

3. Establish Consistent Hierarchy Across All Modules - Every module should decompose into features, and features into subtasks, at roughly uniform depth. If one module has two high-level tasks while another has forty granular subtasks, the task list becomes difficult to estimate, assign, and track. Normalize depth to three levels maximum: module, feature, and specific behavior.

4. Flag Analysis Gaps Rather Than Fabricating Coverage - When the three analysis JSONs disagree or leave areas uncovered, document the gap explicitly rather than inventing tasks to fill it. A note stating "Notification preferences visible in UI analysis but not addressed in business analysis; requires clarification" is more valuable than fabricated tasks based on assumptions.

5. Sequence Modules by Shared Entity Dependencies - When multiple modules reference the same data entity (e.g., both Orders and Invoices depend on Customer), note this dependency and suggest implementing the shared entity module first. Dependency-aware sequencing prevents downstream modules from blocking on undefined data structures and reduces integration rework.

Common Issues

1. Duplicate Features Surviving Deduplication - The UI analyzer calls it "user list," the interaction analyzer calls it "contact browsing," and the business analyzer calls it "customer directory." All three describe the same feature with different terminology. Semantic deduplication requires recognizing synonymous concepts across analysis vocabularies, not just matching identical strings.

2. Unbalanced Module Sizes Distorting Estimates - One module containing forty tasks while others have five suggests either over-decomposition of one area or under-analysis of others. Review module sizes for balance before finalizing the task list. Split oversized modules into logical sub-modules or expand thin modules with missing edge case and interaction tasks.

3. Missing Non-Functional Tasks - Analysis agents focus on visible features but rarely capture loading states, error handling, empty states, accessibility requirements, or responsive layout needs. Add a cross-cutting concerns section to every task list covering these non-functional requirements that apply across all modules but appear in no single analysis output.