Development
Plugin
claude-config
I use Claude Code for most of my work. After months of iteration, I noticed a pattern: LLM-assisted code rots faster than hand-written code.
Plugin Signal59/100Fair
maintained35
capable59
documented100
adopted63
Install
$ npx -y skills add solatis/claude-config --agent claude-code
Run the curl in your terminal, the rest in Claude Code.
What's inside
Skills
11/arxiv-to-mdConvert arXiv papers to LLM-consumable markdown. Invoke when user provides an arXiv ID or URL, or when syncing academic papers from a PDF folder to a markdown destination./cc-historyReference documentation for analyzing Claude Code conversation history files/codebase-analysisInvoke IMMEDIATELY via python script when user requests codebase understanding, architecture comprehension, or repository orientation. Do NOT explore first - the script orchestrates exploration./decision-criticInvoke IMMEDIATELY via python script to stress-test decisions and reasoning. Do NOT analyze first - the script orchestrates the critique workflow./deepthinkInvoke IMMEDIATELY via python script when user requests structured reasoning for open-ended analytical questions. Do NOT explore first - the script orchestrates the thinking workflow./doc-syncSynchronizes docs across a repository. Use when user asks to sync docs.
Show all 11 skillsShow fewer
/incoherenceDetect and resolve incoherence in documentation, code, specs vs implementation./plannerInteractive planning and execution for complex tasks. IMMEDIATELY invoke when user asks to use planner./problem-analysisInvoke IMMEDIATELY via python script when user requests problem analysis or root cause investigation. Do NOT explore first - the script orchestrates the investigation./prompt-engineerInvoke IMMEDIATELY via python script when user requests prompt optimization. Do NOT analyze first - invoke this skill immediately./refactorInvoke IMMEDIATELY via python script when user requests refactoring analysis, technical debt review, or code quality improvement. Do NOT explore first - the script orchestrates exploration.
Agents
5architectUnderstands architecture, project conventions, and quality designsdebuggerAnalyzes bugs through systematic evidence gathering - use for complex debuggingdeveloperImplements your specs with tests - delegate for writing codequality-reviewerReviews code and plans for production risks, project conformance, and structural qualitytechnical-writerCreates documentation optimized for LLM consumption
README
1My Claude Code Workflow
I use Claude Code for most of my work. After months of iteration, I noticed a pattern: LLM-assisted code rots faster than hand-written code. Technical debt accumulates because the LLM does not know what it does not know, and neither do you until it is too late.
This repo is my solution: skills and workflows that force planning before execution, keep context focused, and catch mistakes before they compound.
Why This Exists
LLM-assisted coding fails long-term. Technical debt accumulates because the LLM cannot see it, and you are moving too fast to notice. I treat this as an engineering problem, not a tooling problem.
LLMs are tools, not collaborators. When an engineer says "add retry logic", another engineer infers exponential backoff, jitter, and idempotency. An LLM infers nothing you do not explicitly state. It cannot read the room. It has no institutional memory. It will cheerfully implement the wrong thing with perfect confidence and call it "production-ready".
Larger context windows do not help. Giving an LLM more text is like giving a human a larger stack of papers; attention drifts to the beginning and end, and details in the middle get missed. More context makes this worse. Give the LLM exactly what it needs for the task at hand -- nothing more.
Principles
This workflow is built on four principles.
Context Hygiene
Each task gets precisely the information it needs -- no more. Sub-agents start with a fresh context, so architectural knowledge must be encoded somewhere persistent.
I use a two-file pattern in every directory:
CLAUDE.md -- Claude loads these automatically when entering a directory.
Because they load whether needed or not, content must be minimal: a tabular
index with short descriptions and triggers for when to open each file. When
Claude opens app/web/controller.py, it retrieves just the indexes along that
path -- not prose it might never need.
README.md -- Invisible knowledge: architecture decisions, invariants not apparent from code. The test: if a developer could learn it by reading source files, it does not belong here. Claude reads these only when the CLAUDE.md trigger says to.
The principle is just-in-time context. Indexes load automatically but stay small. Detailed knowledge loads only when relevant.
The technical writer agent enforces token budgets: ~200 tokens for CLAUDE.md, ~500 for README.md, 100 for function docs, 150 for module docs. These limits force discipline -- if you are exceeding them, you are probably documenting what code already shows. Function docs include "use when..." triggers so the LLM knows when to reach for them.
The planner workflow maintains this hierarchy automatically. If you bypass the planner, you maintain it yourself.
Planning Before Execution
LLMs make first-shot mistakes. Always. The workflow separates planning from execution, forcing ambiguities to surface when they are cheap to fix.
Plans capture why decisions were made, what alternatives were rejected, and what risks were accepted. Plans are written to files. When you clear context and start fresh, the reasoning survives.
Review Cycles
Execution is split into milestones -- smaller units that are manageable and can be validated individually. This ensures continuous, verified progress. Without it, execution becomes a waterfall: one small oversight early on and agents compound each mistake until the result is unusable.
Quality gates run at every stage. A technical writer agent checks clarity; a quality reviewer checks completeness. The loop runs until both pass.
Plans pass review before execution begins. During execution, each milestone passes review before the next starts.
Cost-Effective Delegation
The orchestrator delegates to smaller agents -- Haiku for straightforward tasks, Sonnet for moderate complexity. Prompts are injected just-in-time, giving smaller models precisely the guidance they need at each step.
When quality review fails or problems recur, the orchestrator escalates to higher-quality models. Expensive models are reserved for genuine ambiguity, not routine work.
Does This Actually Work?
I have not run formal benchmarks. I can only tell you what I have observed using this workflow to build and maintain non-trivial applications entirely with Claude Code -- backend systems, data pipelines, streaming applications in C++, Python, and Go.
The problems I used to hit constantly are gone:
Ambiguity resolution. You ask an LLM "make me a sandwich" and it comes back with a grilled cheese. Technically correct. Not what you meant. The planning phase forces these misunderstandings to surface before you have built the wrong thing.
Code hygiene. Without review cycles, the same utility function gets reimplemented fifteen times across a codebase. The quality reviewer catches this. The technical writer ensures documentation stays consistent.
LLM-navigable documentation. Function docs include "use when..." triggers. CLAUDE.md files tell the LLM which files matter for a given task. The LLM stops guessing which code is relevant.
Is it better than writing code by hand? I think so, but I cannot speak for everyone. This workflow is opinionated. I am a backend engineer -- the patterns should apply to frontend work, but I have not tested that. If you are less experienced with software engineering, I would like to know whether this helps or adds overhead.
If you are serious about LLM-assisted coding and want to try a structured approach, give it a shot. I would like to hear what works and what does not.
Quick Start
Clone into your Claude Code configuration directory:
# Per-project
git clone https://github.com/solatis/claude-config .claude
# Global (new setup)
git clone https://github.com/solatis/claude-config ~/.claude
# Global (existing ~/.claude)
cd ~/.claude
git remote add workflow https://github.com/solatis/claude-config
git fetch workflow
git merge workflow/main --allow-unrelated-histories
Usage
The workflow for non-trivial changes: explore -> plan -> execute.
1. Explore the problem. Understand what you are dealing with. Figure out the solution.
This is relatively free-form. If the project and/or surface area is particularly
large, use the codebase-analysis skill to explore the project's code properly
before proposing a solution.
2. (Optional) Think it through. I reach for deepthink very often, more than
any other skill. It handles analytical questions where you do not know the answer
structure yet -- taxonomy design, trade-offs, definitional questions, evaluative
judgments, exploratory investigations.
It auto-detects complexity. Quick mode reasons directly. Full mode launches parallel sub-agents with different analytical perspectives, then synthesizes through agreement patterns. Both self-verify.
So, for most analytical questions, deepthink is enough. It explores your codebase when context is missing. Reach for specialized skills only when the question is clearly scoped:
problem-analysis: Root cause analysis specificallydecision-critic: Stress-testing a specific decision
3. Write a plan. "Use your planner skill to write a plan to plans/my-feature.md"
The planner runs your plan through review cycles -- technical writer for clarity, quality reviewer for completeness -- until it passes.
The planner captures all decisions, tradeoffs, and information not visible from the code so that this context does not get lost.
4. Clear context. /clear -- start fresh. You have written everything
needed into the plan.
5. Execute. "Use your planner skill to execute plans/my-feature.md"
The planner delegates to sub-agents. It never writes code directly. Each milestone goes through the developer, then the technical-writer and quality-reviewer. No milestone starts until the previous one passes review.
Where possible, it executes multiple tasks in parallel.
For detailed breakdowns of each skill, see their READMEs:
In Practice
I needed to migrate a legacy C# Windows Service from print-based logging to something that actually rotates files.
The codebase had a homegrown Log() method writing to a single file with File.AppendAllText. No rotation, no log levels, synchronous I/O blocking the thread. Six Console.WriteLine calls scattered elsewhere went nowhere when running as a service.
I started with exploration and analysis in a single prompt:
Use your codebase analysis skill to briefly explore this C# project,
with a focus on all the places where debug logs are currently emitted.
Then use your problem analysis skill to think through an appropriate
logging framework:
* must work with .NET Framework 4.8.1
* must support log rotation out of the box
* we run multiple processes on the same machine, so it needs structured
multi-process support
The codebase analysis found 31 call sites and the Console.WriteLine leakage. The problem analysis evaluated NLog, Serilog, log4net, and Microsoft.Extensions.Logging against my constraints.
The recommendation was NLog. It handles rotation and async out of the box. Multi-process support comes from layout variables. Serilog would work but requires three packages for the same functionality.
I agreed with the recommendation. Not a complicated decision, so I skipped the
decision-critic and moved to planning:
Use your planner skill to write an implementation plan to: plan-logging.md
The planner surfaced two ambiguities:
- Replace all Log() call sites, or just the implementation? Obvious to a human, but worth clarifying upfront.
- Log rotation defaults. The planner assumed 1-day rotation, but I also need size-based rotation at 1GB.
The plan went through review. The technical writer flagged comments that explained what rather than why -- the NLog.config had comments like "configures file target" instead of explaining the rotation strategy. The quality reviewer caught two issues I would have missed: no explicit LogManager.Shutdown() in the service's OnStop() handler, and incorrect file paths missing the src/ prefix.
These are the bugs that ship to production when you skip review cycles. The shutdown issue would have caused log loss on service restart. The path issue would have failed silently.
After fixes, I cleared context and executed:
Use your planner skill to execute: @plan-logging.md
The developer, debugger, technical writer, and quality reviewer run the implementation. Each milestone passes review before the next starts. If the implementation deviated from the plan, I would know.
Other Skills
Not every task needs the full planning workflow. These skills handle specific concerns.
DeepThink
I use this skill multiple times a day -- whenever I do not know what shape the answer should take.
Unlike problem-analysis or decision-critic, deepthink has no fixed
structure. It handles trade-offs, taxonomy questions, evaluative judgments --
whatever you throw at it.
So, when do I reach for it?
Meta-cognitive debugging. I keep making the same mistake. The LLM keeps misunderstanding the task. Why? Something is broken and I need to see it before I can fix it.
Strategy evaluation. Multiple valid approaches exist (and gut feel is not enough). PDF conversion: download the TeX source, parse the PDF directly, or let the LLM render it visually. S3 artifact versioning: timestamp paths, pointer files, checksums. Systematic comparison beats intuition.
Best practices research. What is the canonical approach? How do mature CI/CD systems handle artifact versioning? Industry patterns likely exist -- I just do not know them yet.
Architecture and design. How should these components interact? Where do the delegation boundaries go? I think them through before committing to code.
Consolidation decisions. Should these two skills be merged? Do they serve distinct purposes, or am I maintaining unnecessary complexity?
Two modes, auto-detected. Quick mode reasons directly. Full mode launches parallel sub-agents with distinct analytical perspectives, then synthesizes through agreement patterns.
Use your deepthink skill to think through [question]
For explicit mode selection:
Use your deepthink skill (quick) to [question]
Use your deepthink skill (full) to [question]
Refactor
LLM-generated code accumulates technical debt. The LLM does not see duplication across files or notice god functions growing.
The refactor skill explores multiple dimensions in parallel -- naming, extraction, types, errors, modules, architecture, abstraction -- validates findings against evidence, and outputs prioritized recommendations. It does not generate code; it tells you what to fix and why.
Use it when:
- After LLM-generated features work but feel messy
- Before major changes to identify friction points
- Code review reveals structural issues
- Simple changes require touching many files
Use your refactor skill on src/services/
With focus area:
Use your refactor skill on src/ -- focus on refactoring the rendering engine so that it can be reused in multiple components.
Prompt Engineer
This workflow consists entirely of prompts. Each can be optimized individually.
The skill analyzes prompts, proposes changes with explicit pattern attribution, and waits for your approval before applying anything.
Use it when:
- A sub-agent definition is not performing as expected
- Optimizing a skill's Python script prompts
- Reviewing a multi-prompt workflow for consistency
Use your prompt engineer skill to optimize the system prompt for agents/developer.md
The skill was optimized using itself.
Doc Sync
The CLAUDE.md/README.md hierarchy requires maintenance. The structure changes over time. Documentation drifts.
The doc-sync skill audits and synchronizes documentation across a repository.
Use it when:
- Bootstrapping the workflow on an existing repository
- After major refactors or directory restructuring
- Periodic audits to check for documentation drift
If you use the planning workflow consistently, the technical writer agent handles documentation as part of execution. Doc-sync is primarily for bootstrapping or recovery.
Use your doc-sync skill to synchronize documentation across this repository
For targeted updates:
Use your doc-sync skill to update documentation in src/validators/
File tree
372solatis/claude-configView on GitHub
.github/
CLAUDE.md
workflows/
CLAUDE.md
skills-test.yml
.gitignore
agents/
architect.md
debugger.md
developer.md
quality-reviewer.md
technical-writer.md
conventions/
CLAUDE.md
code-quality/
01-naming-and-types.md
02-structure-and-composition.md
03-patterns-and-idioms.md
04-repetition-and-consistency.md
05-documentation-and-tests.md
06-module-and-dependencies.md
07-cross-file-consistency.md
08-codebase-patterns.md
CLAUDE.md
README.md
diff-format.md
documentation.md
intent-markers.md
REGISTRY.yaml
severity.md
structural.md
temporal.md
LICENSE
output-styles/
direct.md
README.md
skills/
arxiv-to-md/
CLAUDE.md
README.md
SKILL.md
cc-history/
CLAUDE.md
README.md
SKILL.md
CLAUDE.md
codebase-analysis/
CLAUDE.md
README.md
SKILL.md
decision-critic/
CLAUDE.md
README.md
SKILL.md
deepthink/
CLAUDE.md
README.md
SKILL.md
doc-sync/
CLAUDE.md
README.md
references/
CLAUDE.md
trigger-patterns.md
SKILL.md
incoherence/
CLAUDE.md
README.md
SKILL.md
planner/
CLAUDE.md
INTENT.md
README.md
resources/
CLAUDE.md
explore-output-format.md
plan-format.md
plan-json-schema.md
README.md
SKILL.md
problem-analysis/
CLAUDE.md
README.md
SKILL.md
prompt-engineer/
CLAUDE.md
papers/
.gitattributes
CATEGORY_DESCRIPTIONS.md
CLAUDE.md
context/
augmentation/
2021-01-17 What Makes Good In-Context Examples for GPT-3.md
2022-09-28 Generated Knowledge Prompting for Commonsense Reasoning.md
2023-07-14 Unified Demonstration Retriever for In-Context Learning.md
2023-10-21 Universal Self-Adaptive Prompting.md
2023-12-10 Finding Support Examples for In-Context Learning.md
2024-06-23 Diverse Demonstrations Improve In-context Compositional Generalization.md
CLAUDE.md
CLAUDE.md
reframing/
2022-10-20 Rethinking the Role of Demonstrations - What Makes In-Context Learning Work.md
2023-10-23 Context-faithful Prompting for Large Language Models.md
2023-11-12 Large Language Models Understand and Can Be Enhanced by Emotional Stimuli.md
2024-02-18 An Empirical Categorization of Prompting Techniques for Large Language Models - A Practitioner's Guide.md
2024-03-14 Better Zero-Shot Reasoning with Role-Play Prompting.md
2024-04-08 Customizing Language Model Responses with Contrastive In-Context Learning.md
2024-04-18 Rephrase and Respond - Let Large Language Models Ask Better Questions for Themselves.md
2024-06-20 Devil's Advocate - Anticipatory Reflection for LLM Agents.md
2024-06-24 Mirror - A Multiple-perspective Self-Reflection Method for Knowledge-rich Reasoning.md
2024-08-08 Conversational Prompt Engineering.md
2024-09-28 Code Prompting Elicits Conditional Reasoning Abilities in Text and Code LLMs.md
2024-10-09 When A Helpful Assistant Is Not Really Helpful - Personas in System Prompts Do Not Improve Performances of Large Language Models.md
2024-10-16 Lets Argue Both Sides - Argument Generation Can Force Small Models to Utilize Previously Inaccessible Reasoning Capabilities.md
2024-11-01 Multi-expert Prompting Improves Reliability Safety and Usefulness of Large Language Models.md
2024-12-03 Take a Step Back - Evoking Reasoning via Abstraction in Large Language Models.md
2025-02-17 Large Language Models are Contrastive Reasoners.md
2025-03-05 ExpertPrompting - Instructing Large Language Models to be Distinguished Experts.md
2025-08-27 Principled Personas - Defining and Measuring the Intended Effects of Persona Prompting on Task Performance.md
claude-prompt-engineering.md
CLAUDE.md
correctness/
CLAUDE.md
refinement/
2024-06-01 Prompt Chaining or Stepwise Prompt - Refinement in Text Summarization.md
2024-10-01 Iteration of Thought - Leveraging Inner Dialogue for Autonomous Large Language Model Reasoning.md
2024-10-07 Progressive-Hint Prompting Improves Reasoning in Large Language Models.md
2024-10-17 Think Thrice Before You Act - Progressive Thought Refinement in Large Language Models.md
2025-02-11 Self-Harmonized Chain of Thought.md
2025-03-25 Think Twice- Enhancing LLM Reasoning by Scaling Multi-round Test-time Thinking.md
CLAUDE.md
sampling/
2022-03-03 Fantastically Ordered Prompts and Where to Find Them - Overcoming Few-Shot Prompt Order Sensitivity.md
2022-07-02 Rationale-Augmented Ensembles in Language Models.md
2023-01-30 Complexity-Based Prompting for Multi-Step Reasoning.md
2023-02-01 Synthetic Prompting - Generating Chain-of-Thought Demonstrations for Large Language Models.md
2023-03-07 Self-Consistency Improves Chain of Thought Reasoning in Language Models.md
2023-03-31 Fairness-guided Few-shot Prompting for Large Language Models.md
2023-04-12 Boosted Prompt Ensembles for Large Language Models.md
2023-08-23 PREFER - Prompt Ensemble Learning via Feedback-Reflect-Refine.md
2023-08-24 Answering Questions by Meta-Reasoning over Multiple Chains of Thought.md
2023-10-20 Getting MoRE out of Mixture of Language Model Reasoning Experts.md
2023-10-23 Self-ICL - Zero-Shot In-Context Learning with Self-Generated Demonstrations.md
2023-11-29 Universal Self-Consistency for Large Language Model Generation.md
2023-12-03 Tree of Thoughts- Deliberate Problem Solving with Large Language Models.md
2024-02-23 Diversity of Thought Improves Reasoning Abilities of LLMs.md
2024-05-23 Reprompting - Automated Chain-of-Thought Prompt Inference Through Gibbs Sampling.md
2024-07-02 Enhancing Large Language Models in Coding Through Multi-Perspective Self-Consistency.md
2024-07-21 Active Prompting with Chain-of-Thought for Large Language Models.md
2024-08-19 PEDAL - Enhancing Greedy Decoding with Large Language Models using Diverse Exemplars.md
2024-10-19 Persona is a Double-edged Sword - Mitigating the Negative Impact of Role-playing Prompts in Zero-shot Reasoning Tasks.md
2025-04-10 Refining Answer Distributions for Improved Large Language Model Reasoning.md
2025-10-24 Dipper - Diversity in Prompts for Producing Large Language Model Ensembles in Reasoning tasks.md
CLAUDE.md
verification/
2022-10-13 The Unreliability of Explanations in Few-shot Prompting for Textual Reasoning.md
2023-05-06 Refining the Responses of LLMs by Themselves.md
2023-05-25 Self-Refine - Iterative Refinement with Self-Feedback.md
2023-06-23 Human-in-the-Loop through Chain-of-Thought.md
2023-09-25 Chain-of-Verification Reduces Hallucination in Large Language Models.md
2023-10-10 Reflexion - Language Agents with Verbal Reinforcement Learning.md
2023-10-16 Factored Verification - Detecting and Reducing Hallucinations in Summaries of Academic Papers.md
2023-12-09 Language Models Don't Always Say What They Think Unfaithful Explanations in Chain-of-Thought Prompting.md
2024-02-04 REFINER - Reasoning Feedback on Intermediate Representations.md
2024-02-24 CRITIC - Large Language Models Can Self-Correct with Tool-Interactive Critiquing.md
2024-03-14 Large Language Models Cannot Self-Correct Reasoning Yet.md
2024-03-21 Knowing What LLMs Do Not Know - A Simple Yet Effective Self-Detection Method.md
2024-06-06 Self-Contrast - Better Reflection Through Inconsistent Solving Perspectives.md
2024-08-04 On the Self-Verification Limitations of Large Language Models on Reasoning and Planning Tasks.md
2025-03-02 Instruct-of-Reflection - Enhancing Large Language Models Iterative Reflection Capabilities via Dynamic-Meta Instruction.md
2025-05-27 When Two LLMs Debate Both Think They'll Win.md
2025-09-13 Another Turn Better Output - A Turn-Wise Analysis of Iterative LLM Prompting.md
2025-10-09 Multi-Turn Human-LLM Interaction Through the Lens of a Two-Way Intelligibility Protocol.md
2025-12-08 Process Reward Models That Think.md
2025-12-26 Improving Multi-turn Task Completion in Task-Oriented Dialog Systems via Prompt Chaining and Fine-Grained Feedback.md
CLAUDE.md
efficiency/
2023-10-24 Batch Prompting - Efficient Inference with Large Language Model APIs.md
2023-11-20 System 2 Attention - Is Something You Might Need Too.md
2024-07-29 Concise Thoughts - Impact of Output Length on LLM Reasoning and Cost.md
2024-10-19 The Benefits of a Concise Chain of Thought on Problem-Solving in Large Language Models.md
2024-10-28 Unlocking the Capabilities of Thought - A Reasoning Boundary Framework to Quantify and Optimize Chain-of-Thought.md
2024-12-17 Compressed Chain of Thought - Efficient Reasoning through Dense Representations.md
2025-02-12 The Danger of Overthinking - Examining the Reasoning-Action Dilemma in Agentic Tasks.md
2025-03-03 Chain of Draft - Thinking Faster by Writing Less.md
2025-04-01 How Well Do LLMs Compress Their Own Chain-of-Thought - A Token Complexity Approach.md
2025-06-02 Token-Budget-Aware LLM Reasoning.md
2025-09-22 A State-Update Prompting Strategy for Efficient and Robust Multi-turn Dialogue.md
2025-10-24 Sketch-of-Thought - Efficient LLM Reasoning with Adaptive Cognitive-Inspired Sketching.md
2025-11-27 Focused Chain-of-Thought - Efficient LLM Reasoning via Structured Input Information.md
2025-11-28 Behavior-Equivalent Token - Single-Token Replacement for Long Prompts in LLMs.md
2026-01-08 Pruning the Unsurprising - Efficient LLM Reasoning via First-Token Surprisal.md
CLAUDE.md
README.md
reasoning/
CLAUDE.md
decomposition/
2022-03-16 Multi-Stage Prompting for Knowledgeable Dialogue Generation.md
2022-05-19 Selection-Inference - Exploiting Large Language Models for Interpretable Logical Reasoning.md
2022-10-07 Automatic Chain of Thought Prompting in Large Language Models.md
2022-12-08 Successive Prompting for Decomposing Complex Questions.md
2023-01-30 Complexity-Based Prompting for Multi-step Reasoning.md
2023-04-16 Least-to-Most Prompting Enables Complex Reasoning in Large Language Models.md
2023-05-23 PEARL - Prompting Large Language Models to Plan and Execute Actions Over Long Documents.md
2023-05-26 Plan-and-Solve Prompting - Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models.md
2023-10-17 Measuring and Narrowing the Compositionality Gap in Language Models.md
2023-10-25 R3 Prompting - Review, Rephrase and Resolve for Chain-of-Thought Reasoning in Large Language Models under Noisy Context.md
2023-11-15 Thread of Thought Unraveling Chaotic Contexts.md
2023-12-03 Tree of Thoughts - Deliberate Problem Solving with Large Language Models.md
2024-03-02 Skeleton-of-Thought - Prompting LLMs for Efficient Parallel Generation.md
2024-03-27 Look Before You Leap - Problem Elaboration Prompting Improves Mathematical Reasoning in Large Language Models.md
2024-04-02 LM2 - A Simple Society of Language Models Solves Complex Reasoning.md
2024-04-08 ADAPT - As-Needed Decomposition and Planning with Language Models.md
2024-04-11 Decomposed Prompting - A Modular Approach for Solving Complex Tasks.md
2024-04-16 Least-to-Most Prompting Enables Complex Reasoning in Large Language Models.md
2024-06-07 Branch-Solve-Merge Improves Large Language Model Evaluation and Generation.md
2024-07-02 An Examination on the Effectiveness of Divide-and-Conquer Prompting in Large Language Models.md
2024-08-08 Describe Explain Plan and Select - Interactive Planning with Large Language Models Enables Open-World Multi-Task Agents.md
2024-11-17 Narrative-of-Thought - Improving Temporal Reasoning of Large Language Models via Recounted Narratives.md
2025-01-10 Human-In-the-Loop Software Development Agents.md
2025-02-07 Logic-of-Thought - Injecting Logic into Contexts for Full Reasoning in Large Language Models.md
2025-11-15 Cumulative Reasoning with Large Language Models.md
CLAUDE.md
elicitation/
2023-01-29 Large Language Models are Zero-Shot Reasoners.md
2023-03-16 Prompting Large Language Models With the Socratic Method.md
2023-06-14 On Second Thought Let's Not Think Step by Step - Bias and Toxicity in Zero-Shot Reasoning.md
2023-09-22 Self-Explanation Prompting Improves Dialogue Understanding in Large Language Models.md
2023-10-14 Prompting and Evaluating Large Language Models for Proactive Dialogues - Clarification, Target-guided and Non-collaboration.md
2023-11-15 Contrastive Chain-of-Thought Prompting.md
2024-02-22 Hint-before-Solving Prompting - Guiding LLMs to Effectively Utilize Encoded Knowledge.md
2024-03-09 Large Language Models as Analogical Reasoners.md
2024-03-13 Take a Step Back - Evoking Reasoning via Abstraction in Large Language Models.md
2024-03-20 Metacognitive Prompting Improves Understanding in Large Language Models.md
2024-06-11 Faithful Logical Reasoning via Symbolic Chain-of-Thought.md
2024-06-17 Thought Propagation - An Analogical Approach to Complex Reasoning with Large Language Models.md
2024-08-26 Question-Analysis Prompting Improves LLM Performance in Reasoning Tasks.md
2024-10-07 AlignedCoT - Prompting Large Language Models via Native-Speaking Demonstrations.md
2024-10-31 Instance-adaptive Zero-shot Chain-of-Thought Prompting.md
2024-11-19 Re-Reading Improves Reasoning in Large Language Models.md
2024-11-30 Unlocking Structured Thinking in Language Models with Cognitive Prompting.md
2025-05-07 To CoT or not to CoT - Chain-of-Thought Helps Mainly On Math And Symbolic Reasoning.md
CLAUDE.md
structure/
2021-06-10 Calibrate Before Use - Improving Few-Shot Performance of Language Models.md
2023-05-23 Tab-CoT - Zero-shot Tabular Chain of Thought.md
2023-06-06 Large Language Models Can Be Easily Distracted by Irrelevant Context.md
2023-10-09 Guiding Large Language Models via Directional Stimulus Prompting.md
2023-10-23 Program of Thoughts Prompting - Disentangling Computation from Reasoning for Numerical Reasoning Tasks.md
2024-01-18 Principled Instructions Are All You Need For Questioning.md
2024-04-01 The Butterfly Effect of Altering Prompts - How Small Changes and Jailbreaks Affect Large Language Model Performance.md
2024-11-02 SWE-agent - Agent-Computer Interfaces Enable Automated Software Engineering.md
2025-06-24 Meta Prompting for AI Systems.md
2025-07-31 Table as Thought - Exploring Structured Thoughts in LLM Reasoning.md
claude-prompt-engineering.md
CLAUDE.md
README.md
references/
CLAUDE.md
context/
augmentation.md
CLAUDE.md
reframing.md
correctness/
CLAUDE.md
refinement.md
sampling.md
verification.md
efficiency.md
README.md
reasoning/
CLAUDE.md
decomposition.md
elicitation.md
structure.md
SKILL.md
README.md
refactor/
CLAUDE.md
README.md
SKILL.md
scripts/
pytest.ini
skills/
__init__.py
arxiv_to_md/
__init__.py
main.py
sub_agent.py
tex_utils.py
codebase_analysis/
__init__.py
analyze.py
subagent.py
decision_critic/
__init__.py
decision_critic.py
deepthink/
__init__.py
subagent.py
think.py
doc_sync/
__init__.py
incoherence/
__init__.py
incoherence.py
leon_writing_style/
__init__.py
writing_style.py
lib/
__init__.py
CLAUDE.md
conventions.py
io.py
workflow/
__init__.py
ast/
__init__.py
builder.py
CLAUDE.md
dispatch_renderer.py
dispatch.py
nodes.py
README.md
renderer.py
CLAUDE.md
cli.py
constants.py
core.py
discovery.py
formatters/
CLAUDE.md
prompts/
__init__.py
file.py
step.py
subagent.py
quality_docs.py
README.md
types.py
planner/
__init__.py
architect/
__init__.py
plan_design_execute.py
plan_design_qr_fix.py
plan_design.py
CLAUDE.md
cli/
__init__.py
dispatch.py
output.py
plan_commands.py
plan.py
qr_commands.py
qr.py
developer/
__init__.py
exec_implement_execute.py
exec_implement_qr_fix.py
exec_implement.py
plan_code_execute.py
plan_code_qr_fix.py
plan_code.py
orchestrator/
__init__.py
executor.py
planner.py
quality_reviewer/
__init__.py
CLAUDE.md
exec_reconcile.py
impl_code_qr_decompose.py
impl_code_qr_verify.py
impl_docs_qr_decompose.py
impl_docs_qr_verify.py
plan_code_qr_decompose.py
plan_code_qr_verify.py
plan_design_qr_decompose.py
plan_design_qr_verify.py
plan_docs_qr_decompose.py
plan_docs_qr_verify.py
prompts/
__init__.py
decompose.py
qr_verify_base.py
README.md
README.md
shared/
__init__.py
builders.py
constants.py
constraints.py
domain.py
gates.py
qr/
__init__.py
cli.py
constants.py
phases.py
... 37 moreFAQ
claude-config is a Claude Code plugin with 11 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes arxiv-to-md, cc-history, codebase-analysis. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
- What is claude-config?
- I use Claude Code for most of my work. After months of iteration, I noticed a pattern: LLM-assisted code rots faster than hand-written code.
- How do I install claude-config?
- Run these in Claude Code: npx -y skills add solatis/claude-config --agent claude-code. Then prompt normally.
- Does claude-config auto-invoke its skills?
- Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
- Is claude-config free?
- Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.