reasoning-sandwich

Allocate high-reasoning models for planning and verification, cost-effective models for implementation.

1|Updated May 21, 2026
One-click install
npx skills add https://github.com/hiddink-ai/hiddink-harness --skill reasoning-sandwich-hiddink-ai
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reasoning-sandwich
Source: https://github.com/hiddink-ai/hiddink-harness/tree/main/templates/skills/reasoning-sandwich
Command: npx skills add https://github.com/hiddink-ai/hiddink-harness --skill reasoning-sandwich-hiddink-ai

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the issue of inefficient model allocation by ensuring that complex tasks receive high-reasoning power during planning and verification, while routine implementation is handled by cost-effective models.

Core Features & Use Cases

  • Pre-reasoning Phase: Utilizes high-capability models to analyze requirements and identify edge cases before any code is written.
  • Balanced Execution: Employs optimized models for the implementation phase to maintain speed and cost-efficiency.
  • Post-verification Phase: Ensures structural integrity and completeness through automated review and testing.
  • Use Case: When architecting a new feature, the skill forces an initial analysis by a high-tier model, followed by implementation and a final verification check to prevent regressions.

Quick Start

Apply the reasoning-sandwich pattern to the current task by initiating a pre-reasoning analysis phase followed by implementation and verification.

Frequently Asked Questions about reasoning-sandwich

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

FAQPage Schema
How do I optimize model allocation for complex software development workflows?

Model allocation for software workflows is optimized by routing high-capability models to pre-reasoning and verification phases, while cost-effective models handle routine implementation, balancing reasoning depth with execution efficiency.

What is the reasoning-sandwich pattern for architectural design and feature implementation?

The reasoning-sandwich pattern is a multi-stage model allocation strategy that forces high-tier model analysis before code implementation, followed by automated verification, ensuring accuracy in architectural design and feature implementation.

Can I use different model tiers to balance reasoning depth and execution efficiency?

Different model tiers can be orchestrated to balance reasoning depth and execution efficiency by assigning high-capability models to requirement analysis and verification, and optimized models to the implementation phase.

How do I prevent regressions when making security-sensitive changes?

Preventing regressions during security-sensitive changes requires a post-verification phase using high-capability models to ensure structural integrity and completeness through automated review and testing after implementation.

When should I use a pre-reasoning analysis phase before writing code?

A pre-reasoning analysis phase should be used when architecting new features or handling complex workflows, utilizing high-capability models to analyze requirements and identify edge cases before any code is written.