Comprehensive developer toolkit providing reusable skills for Java/Spring Boot, TypeScript/NestJS/React/Next.js, Python, PHP, AWS CloudFormation, AI/RAG, DevOps, and more.
82
82%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Risky
Do not use without reviewing
This reference provides comprehensive frameworks for implementing effective chain-of-thought (CoT) reasoning that improves model performance on complex, multi-step problems.
Let's think step by step to solve this problem:
1. First, I need to understand what the question is asking for
2. Then, I'll identify the key information and constraints
3. Next, I'll consider different approaches to solve it
4. I'll work through the solution methodically
5. Finally, I'll verify my answer makes sense
Problem: {problem_statement}
Step 1: Understanding the question
{analysis}
Step 2: Key information and constraints
{information_analysis}
Step 3: Solution approach
{approach_analysis}
Step 4: Working through the solution
{detailed_solution}
Step 5: Verification
{verification}
Final Answer: {conclusion}Let me think through this systematically, breaking down the problem and checking my reasoning at each step.
**Problem**: {problem_description}
**Step 1: Problem Analysis**
- What am I being asked to solve?
- What information is provided?
- What are the constraints?
- My confidence in understanding: {score}/10
**Step 2: Strategy Selection**
- Possible approaches:
1. {approach_1}
2. {approach_2}
3. {approach_3}
- Selected approach: {chosen_approach}
- Rationale: {reasoning_for_choice}
**Step 3: Execution**
- {detailed_step_by_step_solution}
**Step 4: Verification**
- Does the answer make sense?
- Have I addressed all parts of the question?
- Confidence in final answer: {score}/10
**Final Answer**: {solution_with_confidence_score}Solve the following math problem step by step.
Example 1:
Problem: A store sells apples for $2 each and oranges for $3 each. If John buys 4 apples and 2 oranges, and spends exactly $14, how much does each fruit cost?
Step 1: Set up the equation
Let a = cost of apples, o = cost of oranges
4a + 2o = 14
Step 2: Simplify the equation
Divide both sides by 2: 2a + o = 7
Step 3: Test integer solutions
If a = 2, then 2(2) + o = 7 → o = 3
If a = 3, then 2(3) + o = 7 → o = 1
Step 4: Verify the original problem
For a=2, o=3: 4(2) + 2(3) = 8 + 6 = 14 ✓
For a=3, o=1: 4(3) + 2(1) = 12 + 2 = 14 ✓
Both solutions work, so apples could cost $2 and oranges $3, OR apples $3 and oranges $1.
Example 2:
Problem: Sarah is twice as old as Tom was 3 years ago. In 5 years, Sarah will be 1.5 times Tom's current age. How old are they now?
Step 1: Define variables
Let S = Sarah's current age, T = Tom's current age
Step 2: Set up equations
"Sarah is twice as old as Tom was 3 years ago": S = 2(T - 3)
"In 5 years, Sarah will be 1.5 times Tom's current age": S + 5 = 1.5T
Step 3: Solve the system
From first equation: S = 2T - 6
Substitute into second: (2T - 6) + 5 = 1.5T
2T - 1 = 1.5T
0.5T = 1
T = 2
Step 4: Find Sarah's age
S = 2(2) - 6 = 4 - 6 = -2
Step 5: Check for validity
Negative age is impossible, so I must have made an error.
Let me re-examine the problem...
Actually, let me try again:
S = 2(T - 3) = 2T - 6
S + 5 = 1.5T
Substitute: (2T - 6) + 5 = 1.5T
2T - 1 = 1.5T
0.5T = 1
T = 2 years old
S = 2(2 - 3) = 2(-1) = -2
This gives a negative age. The problem might have no solution with integer ages.
Now solve:
Problem: {math_problem}
Step 1: Define variables
{variable_definitions}
Step 2: Set up equations
{equation_setup}
Step 3: Solve the system
{solution_process}
Step 4: Verify the solution
{verification}
Final Answer: {answer}Analyze the logical argument and determine if it's valid.
Example 1:
Premise 1: All birds can fly
Premise 2: Penguins are birds
Conclusion: Therefore, penguins can fly
Step 1: Analyze the structure
This is a syllogism with form:
All A are B
C is A
Therefore, C is B
Step 2: Evaluate premise validity
Premise 1: "All birds can fly" - This is false (penguins, ostriches cannot fly)
Premise 2: "Penguins are birds" - This is true
Step 3: Check logical validity
The logical structure is valid, but since Premise 1 is false, the conclusion may not be true
Step 4: Real-world verification
In reality, penguins cannot fly despite being birds
Conclusion: The argument is logically valid but soundness fails due to false premise
Example 2:
Premise 1: If it rains, then the ground gets wet
Premise 2: It is raining
Conclusion: Therefore, the ground gets wet
Step 1: Analyze the structure
This is modus ponens:
If P, then Q
P
Therefore, Q
Step 2: Evaluate premise validity
Premise 1: "If it rains, then the ground gets wet" - Generally true
Premise 2: "It is raining" - Given as true
Step 3: Check logical validity
Modus ponens is a valid argument form
Step 4: Verify the conclusion
Given the premises, the conclusion follows logically
Conclusion: The argument is both logically valid and sound
Now analyze:
Argument: {logical_argument}
Step 1: Analyze the argument structure
{structure_analysis}
Step 2: Evaluate premise validity
{premise_evaluation}
Step 3: Check logical validity
{validity_check}
Step 4: Verify the conclusion
{conclusion_verification}
Final Assessment: {argument_validity_assessment}I'll solve this problem using three different approaches and see which result is most reliable.
**Problem**: {complex_problem}
**Approach 1: Direct Calculation**
{first_approach_reasoning}
Result 1: {result_1}
**Approach 2: Logical Deduction**
{second_approach_reasoning}
Result 2: {result_2}
**Approach 3: Pattern Recognition**
{third_approach_reasoning}
Result 3: {result_3}
**Consistency Analysis:**
- Approach 1 and 2 agree: {yes/no}
- Approach 1 and 3 agree: {yes/no}
- Approach 2 and 3 agree: {yes/no}
**Final Decision:**
{majority_result} appears in {count} out of 3 approaches.
Confidence: {high/medium/low}
Most Likely Answer: {final_answer_with_confidence}Let me solve this step by step and verify each step.
**Problem**: {problem_description}
**Step 1: Initial Analysis**
{initial_analysis}
Verification: Does this make sense? {verification_1}
**Step 2: Solution Development**
{solution_development}
Verification: Does this logically follow from step 1? {verification_2}
**Step 3: Result Calculation**
{result_calculation}
Verification: Does this answer the original question? {verification_3}
**Step 4: Cross-Check**
Let me try a different approach to confirm:
{alternative_approach}
Results comparison: {comparison_analysis}
**Final Answer:**
{conclusion_with_verification_status}Debug the following code by analyzing it step by step.
**Code:**
{code_snippet}
**Step 1: Understand the Code's Purpose**
{purpose_analysis}
**Step 2: Identify Expected Behavior**
{expected_behavior}
**Step 3: Trace the Execution**
{execution_trace}
**Step 4: Find the Error**
{error_identification}
**Step 5: Propose Fix**
{fix_proposal}
**Step 6: Verify the Fix**
{fix_verification}
**Fixed Code:**
{corrected_code}Analyze this data systematically to draw meaningful conclusions.
**Data:**
{dataset}
**Step 1: Understand the Data Structure**
{data_structure_analysis}
**Step 2: Identify Patterns and Trends**
{pattern_identification}
**Step 3: Calculate Key Metrics**
{metrics_calculation}
**Step 4: Compare with Benchmarks**
{benchmark_comparison}
**Step 5: Formulate Insights**
{insight_generation}
**Step 6: Validate Conclusions**
{conclusion_validation}
**Key Findings:**
{summary_of_insights}Generate creative solutions to this challenging problem.
**Problem:**
{creative_problem}
**Step 1: Reframe the Problem**
{problem_reframing}
**Step 2: Brainstorm Multiple Angles**
- Technical approach: {technical_ideas}
- Business approach: {business_ideas}
- User experience approach: {ux_ideas}
- Unconventional approach: {unconventional_ideas}
**Step 3: Evaluate Each Approach**
{approach_evaluation}
**Step 4: Synthesize Best Elements**
{synthesis_process}
**Step 5: Develop Final Solution**
{solution_development}
**Step 6: Test for Feasibility**
{feasibility_testing}
**Recommended Solution:**
{final_creative_solution}This framework provides comprehensive patterns for implementing effective chain-of-thought reasoning across diverse problem types and applications.
plugins
developer-kit-ai
skills
chunking-strategy
prompt-engineering
developer-kit-aws
skills
aws
aws-cli-beast
aws-cost-optimization
aws-drawio-architecture-diagrams
aws-sam-bootstrap
aws-cloudformation
aws-cloudformation-auto-scaling
references
aws-cloudformation-bedrock
references
aws-cloudformation-cloudfront
references
aws-cloudformation-cloudwatch
references
aws-cloudformation-dynamodb
references
aws-cloudformation-ec2
aws-cloudformation-ecs
references
aws-cloudformation-elasticache
aws-cloudformation-iam
references
aws-cloudformation-lambda
references
aws-cloudformation-rds
aws-cloudformation-s3
references
aws-cloudformation-security
references
aws-cloudformation-task-ecs-deploy-gh
aws-cloudformation-vpc
developer-kit-core
skills
developer-kit-java
skills
aws-lambda-java-integration
aws-rds-spring-boot-integration
aws-sdk-java-v2-bedrock
aws-sdk-java-v2-core
aws-sdk-java-v2-dynamodb
aws-sdk-java-v2-kms
aws-sdk-java-v2-lambda
aws-sdk-java-v2-messaging
aws-sdk-java-v2-rds
aws-sdk-java-v2-s3
aws-sdk-java-v2-secrets-manager
graalvm-native-image
langchain4j
langchain4j-mcp-server-patterns
langchain4j-ai-services-patterns
references
langchain4j-mcp-server-patterns
references
langchain4j-rag-implementation-patterns
references
langchain4j-spring-boot-integration
langchain4j-testing-strategies
langchain4j-tool-function-calling-patterns
langchain4j-vector-stores-configuration
references
qdrant
references
spring-ai-mcp-server-patterns
references
spring-boot-actuator
spring-boot-cache
spring-boot-crud-patterns
spring-boot-dependency-injection
spring-boot-event-driven-patterns
spring-boot-openapi-documentation
spring-boot-project-creator
spring-boot-resilience4j
spring-boot-rest-api-standards
spring-boot-saga-pattern
spring-boot-security-jwt
assets
references
scripts
spring-boot-test-patterns
spring-data-jpa
references
spring-data-neo4j
references
unit-test-application-events
unit-test-bean-validation
unit-test-boundary-conditions
unit-test-caching
unit-test-config-properties
unit-test-controller-layer
unit-test-exception-handler
unit-test-json-serialization
unit-test-mapper-converter
unit-test-parameterized
unit-test-scheduled-async
unit-test-service-layer
unit-test-utility-methods
unit-test-wiremock-rest-api
developer-kit-php
skills
aws-lambda-php-integration
developer-kit-python
skills
aws-lambda-python-integration
developer-kit-tools
developer-kit-typescript
skills
aws-lambda-typescript-integration
better-auth
drizzle-orm-patterns
dynamodb-toolbox-patterns
references
nestjs
nestjs-best-practices
nestjs-code-review
nestjs-drizzle-crud-generator
scripts
nextjs-app-router
nextjs-authentication
nextjs-code-review
nextjs-data-fetching
references
nextjs-deployment
nextjs-performance
nx-monorepo
react-code-review
react-patterns
references
shadcn-ui
tailwind-css-patterns
references
tailwind-design-system
references
turborepo-monorepo
typescript-docs
typescript-security-review
zod-validation-utilities