task-architect

Read project files and ask clarifying questions to produce a task brief.

Updated Apr 3, 2026
One-click install
npx skills add https://github.com/BEIRUX/agent-skills --skill task-architect-beirux
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-architect
Source: https://github.com/BEIRUX/agent-skills/tree/main/task-architect
Command: npx skills add https://github.com/BEIRUX/agent-skills --skill task-architect-beirux

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Task Architect eliminates guesswork and misaligned implementations by forcing structured intake: it reads relevant project files, classifies the task, and asks targeted clarifying questions before any work begins so that scope and requirements are crystal clear.

Core Features & Use Cases

  • Discovery-first workflow: Classifies tasks (content-update, new-build, bug-fix, refactor, design-ui) and determines what to read based on type.
  • File-aware questioning: Reads referenced files and cites filenames or patterns when asking one question at a time to rapidly converge on clear requirements.
  • Contracted brief before execution: Produces a concise task brief listing files to modify, execution steps, scope, and constraints; waits for explicit approval before implementing changes.
  • Use Cases: Rewriting site copy across multiple pages, planning a new feature implementation, scoping a refactor, or triaging and debugging a reported issue.

Quick Start

Use the task-architect skill by starting with /task-architect and a short description of the work you want planned.

Frequently Asked Questions about task-architect

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

FAQPage Schema
How do I plan a complex coding task before starting implementation?

Planning a complex coding task requires structured discovery where relevant project files are read and sequential clarifying questions are asked to define scope. This approach produces a concise task brief listing files to modify, execution steps, and constraints before any coding begins.

What is the best way to scope a software refactor or new feature build?

Scoping a software refactor or new feature build involves classifying the task type and reading referenced project files to understand existing patterns. Targeted clarifying questions are then asked one at a time to converge on clear requirements and produce a contracted brief.

How do clarifying questions help with task intake and discovery?

Clarifying questions help with task intake by forcing structured discovery before implementation begins. Asking one question per message while citing referenced filenames or patterns rapidly converges on accurate context and crystal-clear scope requirements.

Can I use this structured planning workflow for bug fixes and UI changes?

Yes, this structured planning workflow supports bug fixes and design or UI changes. It applies to content updates, new builds, and refactors by reading relevant project files, asking targeted questions, and producing a task brief that requires explicit approval before implementing changes.

What limitations exist when creating a task brief for large codebases?

Creating a task brief for large codebases requires reading referenced files and loading question patterns, meaning intake speed depends on file accessibility and size. The workflow waits for explicit approval of the concise brief before implementation, which may add latency to urgent fixes.