$ loading_
Document agent decisions and pass structured context during agent handoffs.
The material indicates an open-source, prompt/document-only reasoning skill. It requires no secrets and declares no remote connectivity, local execution, or data/file access, so overall risk is low. The main caveat is weaker supply-chain assurance due to 0 stars, no declared license, and unknown maintenance status, though no concrete red flags are evident.
The material explicitly states no required secrets or environment variables. There is no indication of API keys, tokens, or other sensitive credentials being collected, stored, or forwarded.
The material states there are no remote endpoint hosts, and the system marks it as prompt-only. No networking, data upload, or transmission of user content to third-party services is described.
Based on the description and README, this skill provides formatting/rules for recording decisions and handoff context. There is no indication of spawning local processes, running scripts, invoking a shell, or using other system capabilities.
The documentation only describes generating/presenting structured Reasoning Logs and Handoff Envelopes. It does not declare permissions to read, write, or enumerate local files, databases, repository contents, or other resources.
Positive factors: it is an open-source GitHub repository and marked open-source, making it at least somewhat auditable. Caveats: no declared license, 0 stars, and unknown maintenance reduce source trustworthiness; however, no high-risk red flags such as closed-source data exfiltration, suspicious injection, or clearly misleading claims are evident.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "reasoning" skill from askskill: 1. Download https://raw.githubusercontent.com/microsoft/devsquad-copilot/main/.github/plugins/devsquad/skills/reasoning/SKILL.md 2. Save it as ~/.claude/skills/reasoning/SKILL.md 3. Reload skills and tell me it's ready
Create a Reasoning Log for the current SDD agent run. Record key decisions made, justification for each decision, rejected alternatives, and open questions for the next step. Output it as a structured list.
A structured decision log listing decisions, rationale, alternatives, and follow-up items.
Generate a handoff envelope that packages the current agent's goal, completed work, key decisions, constraints, unresolved issues, and recommended next steps for the next agent.
A structured handoff package that lets the next agent continue the task efficiently.
Below is a list of conclusions from an agent run. Add the rationale, supporting information, and risks behind each conclusion, then format everything as a standard Reasoning Log: 1. Prioritize the API implementation 2. Defer edge-case handling 3. Move testing to the next phase
A completed standardized reasoning log where each conclusion includes clear rationale and risk notes.
Guidelines for making SDD agent reasoning auditable and traceable.
Two complementary mechanisms:
Upon completing execution and before creating artifacts, present the user with a summary of decisions made.
## Reasoning
### Decisions
| # | Decision | Applied principle | Alternatives considered | Justification | Confidence |
|---|----------|-------------------|------------------------|---------------|------------|
| 1 | [what was decided] | [principle or heuristic that guided the choice] | [discarded options] | [why this choice] | [High/Medium/Low] |
### Assumptions
- [assumption made and basis for it]
### Missing information
- [data that was missing and how it impacts the decisions above]
Connects each decision to the reusable foundation that guided it. The goal is to make engineering judgment visible — not just what was decided, but what reasoning pattern was used.
Examples of principles:
| Type | Example |
|---|---|
| Design | "Separation of concerns", "Fail-fast", "Idempotency" |
| Trade-off | "Latency vs consistency", "Simplicity vs extensibility" |
| Operational | "Observability in production", "Graceful degradation" |
| Security | "Principle of least privilege", "Defense in depth" |
| Pragmatic | "YAGNI", "Rule of 3 uses before abstracting" |
Rules:
coding-guidelines.md or ADRs) take priority over generic industry principles.| Level | Criterion | Expectation |
|---|---|---|
| High | Based on explicit requirement, concrete data, or validated decision (accepted ADR, approved spec) | Does not require additional validation |
| Medium | Inferred from existing context (envisioning, project patterns) without explicit validation | Validate with stakeholder before depending on this decision |
| Low | Reasonable assumption without direct evidence; industry standard applied due to lack of information | Requires validation before proceeding; mark what is needed to raise confidence |
When performing a handoff to another agent, include a structured context block along with the handoff prompt.
### Handoff Context
**Relevant artifacts**: [list of files the next agent should read]
**Inherited assumptions**:
- [assumption the upstream agent made that influences the downstream]
**Pending decisions** (for the next agent to resolve):
- [decision that was left open and why]
**Discarded information**:
- [context or alternative that was considered and discarded, with reason]
…
Standardize formatting and writing style for project Markdown documentation.
Systematically triage failures and fix broken builds or unexpected runtime issues.
Design and review software architecture diagrams for clearer, documentation-friendly visuals.
Create, switch, and verify Git branches before starting implementation work.
Initialize projects or verify and generate up-to-date SDD documentation templates.
Clarify ambiguous plans and requirements through rigorous questioning and assumption testing.
Create or review ADRs to compare technologies and document design trade-offs.
Execute implementation plans by splitting and advancing independent tasks in-session.
Capture and reuse codebase learnings to avoid repeating implementation and review mistakes.
Create and maintain ADRs with checks, references, and planning support.
Execute implementation plans with task-specific subagents and code review checkpoints.
Create process documentation with test-driven validation before finalizing the draft.