DEV Community: CBT Tools

CBT Techniques for Developer Burnout: How to Reframe 'I'm Not Productive Enough

CBT Tools — Sat, 10 Oct 2026 12:06:39 +0000

If you've ever stared at your IDE at 2 PM, brain fogged, and thought "I'm not productive enough", you're not alone. Developer burnout is at record highs — and the inner monologue that drives it is remarkably predictable.

The good news? That inner monologue follows patterns. And patterns can be hacked.

This tutorial shows you how to use Cognitive Behavioral Therapy (CBT) techniques — the same evidence-based methods therapists use — to identify and reframe the cognitive distortions that fuel developer burnout. We'll build a simple Python tool along the way.

What Is CBT (And Why Should Developers Care)?

CBT is a structured, evidence-based therapy that works by identifying the cognitive distortions — systematic errors in thinking — that drive negative emotions. For developers, these distortions often manifest as:

"I should be shipping faster" (Should statements)
"One bad PR review means I'm a bad engineer" (All-or-nothing thinking)
"Everyone else is more productive than me" (Comparison distortion)
"If I don't work this weekend, I'll fall behind forever" (Catastrophizing)

CBT gives you a structured way to catch these thoughts, examine the evidence, and reframe them. Think of it as debugging for your brain.

The CBT Thought Record: Your Mental Debug Log

The core CBT tool is the Thought Record — a structured log where you:

Situation: What triggered the thought?
Automatic Thought: What did your brain say?
Emotion: What did you feel? (0-100 intensity)
Cognitive Distortion: Which thinking error is this?
Evidence For: What supports the thought?
Evidence Against: What contradicts it?
Balanced Thought: A fair, evidence-based reframe
New Emotion: How do you feel now? (0-100)

Let's build one in Python.

Building a CBT Thought Record Tool in Python

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional
import json

@dataclass
class ThoughtRecord:
    """A single CBT thought record entry."""
    situation: str
    automatic_thought: str
    emotion: str
    emotion_intensity: int  # 0-100
    cognitive_distortion: str
    evidence_for: str
    evidence_against: str
    balanced_thought: str
    new_emotion_intensity: int  # 0-100
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())

# Common developer cognitive distortions
DEVELOPER_DISTORTIONS = {
    "all_or_nothing": "All-or-nothing thinking: one failure = total failure",
    "catastrophizing": "Catastrophizing: assuming the worst possible outcome",
    "should_statements": "Should statements: rigid rules about how you 'should' perform",
    "comparison": "Comparison distortion: comparing your inside to others' outside",
    "personalization": "Personalization: taking blame for things outside your control",
    "mental_filter": "Mental filter: focusing only on negatives, filtering out positives",
    "labeling": "Labeling: 'I am a bad engineer' instead of 'I made a mistake'",
}

def create_thought_record() -> ThoughtRecord:
    """Interactive CLI to create a thought record."""
    print("=== CBT Thought Record ===\n")

    situation = input("What situation triggered the thought?\n> ")
    auto_thought = input("\nWhat did your brain automatically say?\n> ")
    emotion = input("\nWhat emotion did you feel? (e.g., anxiety, guilt, shame)\n> ")
    intensity = int(input("\nIntensity 0-100?\n> "))

    print("\nCommon developer distortions:")
    for key, desc in DEVELOPER_DISTORTIONS.items():
        print(f"  {key}: {desc}")
    distortion = input("\nWhich distortion matches?\n> ")

    evidence_for = input("\nEvidence FOR the thought:\n> ")
    evidence_against = input("\nEvidence AGAINST the thought:\n> ")
    balanced = input("\nBalanced reframe:\n> ")
    new_intensity = int(input("\nNew emotion intensity 0-100?\n> "))

    return ThoughtRecord(
        situation=situation,
        automatic_thought=auto_thought,
        emotion=emotion,
        emotion_intensity=intensity,
        cognitive_distortion=distortion,
        evidence_for=evidence_for,
        evidence_against=evidence_against,
        balanced_thought=balanced,
        new_emotion_intensity=new_intensity,
    )

# Example: Developer burnout thought record
example = ThoughtRecord(
    situation="PR got 3 change requests on code I worked on all week",
    automatic_thought="I'm not productive enough. I should have gotten it right the first time.",
    emotion="shame",
    emotion_intensity=75,
    cognitive_distortion="should_statements",
    evidence_for="The PR did need changes.",
    evidence_against="Change requests are normal. I shipped 4 other PRs this week that merged cleanly. Senior devs get change requests too. Code review is collaborative, not a test.",
    balanced_thought="Change requests are part of the process, not a verdict on my worth. I can address the feedback and learn from it.",
    new_emotion_intensity=30,
)

print(json.dumps(example.__dict__, indent=2))

Run this and you'll see the emotional intensity drop from 75 → 30 — just by examining the evidence.

The 6 Burnout Thought Patterns (And How to Reframe Them)

Developer burnout has six characteristic thought patterns. Here's each one with its reframe:

1. "I'm Not Productive Enough"

Distortion: Comparison + Should statements
Reframe: "Productivity is not a single metric. I shipped working code, helped in code review, and unblocked a teammate. That's a productive day."

2. "Everyone Else Ships Faster Than Me"

Distortion: Comparison distortion (comparing your inside to their outside)
Reframe: "I see their merged PRs, not their WIP branches, reverts, and debug sessions. I don't have their full picture."

3. "If I Rest, I'll Fall Behind"

Distortion: Catastrophizing
Reframe: "Taking a break today costs ~2 hours. Burning out costs ~2 months. The math favors rest."

4. "My Worth = My Output"

Distortion: Labeling / All-or-nothing
Reframe: "I am a person who writes code, among many other things. My worth is not a function of my commit count."

5. "I Should Be Able to Handle This"

Distortion: Should statements
Reframe: "Burnout is a well-documented occupational phenomenon (ICD-11). It's not a personal failure. It's a signal that something in the environment needs to change."

6. "It's Too Late to Change Anything"

Distortion: All-or-nothing + Catastrophizing
Reframe: "I can change one thing today: take a lunch break, set a boundary, log off at 6. Small changes compound."

Automating the Reframe: A Distortion Detector

import re

# Pattern → distortion mapping
BURNTOUT_PATTERNS = {
    r"not (productive|shipping|fast) enough": "comparison",
    r"everyone else (is|does|ships)": "comparison",
    r"i should (be|have|not)": "should_statements",
    r"(always|never|forever|impossible)": "all_or_nothing",
    r"if i (rest|stop|take a break)": "catastrophizing",
    r"i am (a |an )?(bad|failure|fraud|imposter)": "labeling",
    r"(too late|no point|what's the use)": "all_or_nothing",
}

def detect_distortions(journal_entry: str) -> list[tuple[str, str]]:
    """Scan a journal entry for cognitive distortions."""
    entry_lower = journal_entry.lower()
    found = []
    for pattern, distortion in BURNTOUT_PATTERNS.items():
        matches = re.findall(pattern, entry_lower)
        if matches:
            found.append((distortion, matches))
    return found

# Test it
journal = """
I'm not productive enough today. Everyone else ships faster.
I should be able to handle this workload. If I rest, I'll fall behind.
It's too late to change anything.
"""

distortions = detect_distortions(journal)
for d, matches in distortions:
    print(f"⚠️  {d}: {matches}")

Output:

⚠️  comparison: ['productive', 'ships']
⚠️  should_statements: ['be']
⚠️  catastrophizing: ['rest']
⚠️  all_or_nothing: ['too late']

The Behavioral Experiment: Testing Your Beliefs

CBT isn't just thinking differently — it's testing whether your beliefs are accurate. For developers, this means running behavioral experiments:

@dataclass
class BehavioralExperiment:
    """Test a burnout belief against reality."""
    belief: str
    prediction: str  # What you think will happen
    experiment: str  # What you'll do
    actual_outcome: str = ""
    belief_confirmed: Optional[bool] = None

    def record_outcome(self, outcome: str):
        self.actual_outcome = outcome
        # Did reality match the prediction?
        self.belief_confirmed = outcome.lower() in self.prediction.lower()

# Example: "If I log off at 6 PM, my team will think I'm lazy"
experiment = BehavioralExperiment(
    belief="If I log off at 6 PM, my team will think I'm lazy",
    prediction="Team will comment on my early departure or reduce my responsibilities",
    experiment="Log off at 6 PM for 3 days. Observe team reactions.",
)

# After 3 days:
experiment.record_outcome("No one commented. One teammate said 'good boundaries'. PR merged normally next morning.")
print(f"Belief confirmed: {experiment.belief_confirmed}")
print(f"The belief was WRONG. Logging off at 6 is safe.")

Free Interactive CBT Tools

I've built a set of free, privacy-first CBT tools that run entirely in your browser — no signup, no backend, no data collection:

🔗 CBT Toolkit on GitHub

The toolkit includes:

Interactive thought record builder
Cognitive distortion reference with developer-specific examples
CBT techniques for 50+ specific conditions (anxiety, burnout, imposter syndrome, perfectionism)
All vanilla JavaScript, all open source

When to Seek Professional Help

CBT self-help tools are powerful, but they're not a substitute for professional therapy. Seek help if:

Burnout symptoms persist > 2 weeks despite self-help
You experience thoughts of self-harm
Burnout is affecting your physical health (sleep, appetite, chest pain)
You're using substances to cope

Resources:

988 (US Suicide & Crisis Lifeline — call or text)
Your company's EAP (Employee Assistance Program)
Psychology Today's therapist finder (psychologytoday.com)

Summary

Developer burnout is driven by predictable cognitive distortions. CBT gives you structured tools to:

Catch the automatic thought (Thought Record)
Identify the distortion (Pattern matching)
Examine the evidence (For and against)
Reframe to a balanced perspective
Test with behavioral experiments

The thought record takes 5 minutes. The payoff is shifting from "I'm not productive enough" to "I'm doing sustainable work at a sustainable pace" — and actually believing it.

This tutorial is educational, not medical advice. If you're struggling, please reach out to a mental health professional or call 988.

Free CBT Thought Record Template

I built a CBT Thought Record Notion template with the 7-column method, 10 cognitive distortions reference, worked example, and daily practice guide.

Get it here → Gumroad - CBT Thought Record ($7)

Or duplicate the Notion template directly and customize it.

How to Build a CBT Thought Record Journal in Python (Mental Health Tooling)

CBT Tools — Sat, 10 Oct 2026 11:15:56 +0000

If you've ever struggled with anxiety, negative self-talk, or emotional spirals, you've probably heard of Cognitive Behavioral Therapy (CBT). It's one of the most evidence-backed therapeutic approaches for anxiety, depression, and dozens of other conditions.

But here's the thing: the core CBT technique — the thought record — is essentially a structured way to debug your own thinking. And if you're a developer, you already know how to debug.

In this tutorial, I'll show you how to build a CBT Thought Record Journal in Python — a CLI tool that guides you through the 7-column thought record, stores entries as JSON, and lets you review patterns over time.

What Is a Thought Record?

A thought record (also called a "dysfunctional thought record" or "ABCDE worksheet") is a structured table where you:

Situation — Describe what triggered the emotional response
Emotions — Rate intensity (0-100)
Automatic Thoughts — What went through your mind?
Cognitive Distortion — Which thinking trap did you fall into?
Evidence For — What supports the thought?
Evidence Against — What contradicts it?
Balanced Thought — A fairer, more accurate reframe

This structure comes from Aaron Beck's cognitive therapy model. Research shows that regular practice reduces anxiety and depression symptoms by 40-60% over 12-20 sessions.

The 10 Common Cognitive Distortions

Before we code, here are the distortions our tool will detect:

DISTORTIONS = {
    'all_or_nothing': 'All-or-Nothing Thinking (splitting)',
    'overgeneralization': 'Overgeneralization',
    'mental_filter': 'Mental Filter (focusing only on negatives)',
    'disqualifying_positive': 'Disqualifying the Positive',
    'mind_reading': 'Jumping to Conclusions (Mind Reading)',
    'fortune_telling': 'Jumping to Conclusions (Fortune Telling)',
    'magnification': 'Magnification (Catastrophizing) or Minimization',
    'emotional_reasoning': 'Emotional Reasoning',
    'should_statements': 'Should Statements',
    'labeling': 'Labeling and Mislabeling',
    'personalization': 'Personalization and Blame',
}

Building the Tool

Step 1: Data Model

from dataclasses import dataclass, field
from datetime import datetime
from typing import List
import json

@dataclass
class ThoughtRecord:
    date: str = field(default_factory=lambda: datetime.now().isoformat())
    situation: str = ''
    emotions: dict = field(default_factory=dict)
    automatic_thoughts: str = ''
    distortions: List[str] = field(default_factory=list)
    evidence_for: str = ''
    evidence_against: str = ''
    balanced_thought: str = ''
    new_emotion_rating: dict = field(default_factory=dict)

    def to_dict(self):
        return {
            'date': self.date,
            'situation': self.situation,
            'emotions': self.emotions,
            'automatic_thoughts': self.automatic_thoughts,
            'distortions': self.distortions,
            'evidence_for': self.evidence_for,
            'evidence_against': self.evidence_against,
            'balanced_thought': self.balanced_thought,
            'new_emotion_rating': self.new_emotion_rating,
        }

Step 2: Distortion Detector

This is where it gets interesting. We can use simple pattern matching to suggest which distortions might be present:

import re

def detect_distortions(thought: str) -> list:
    thought_lower = thought.lower()
    detected = []

    if re.search(r'\b(always|never|completely|totally|ruined|perfect|failure|success)\b', thought_lower):
        detected.append('all_or_nothing')

    if re.search(r'\b(every time|nothing ever)\b', thought_lower):
        detected.append('overgeneralization')

    if re.search(r'\b(disaster|end of|over for|can.?t handle|unbearable|worst)\b', thought_lower):
        detected.append('magnification')

    if re.search(r'\b(should|must|have to|ought to)\b', thought_lower):
        detected.append('should_statements')

    if re.search(r'\b(i feel|it feels|feels like)\b', thought_lower):
        detected.append('emotional_reasoning')

    if re.search(r'\b(i am a |i.m a |they are a )\b', thought_lower):
        detected.append('labeling')

    if re.search(r'\b(they think|they know|everyone thinks|people will)\b', thought_lower):
        detected.append('mind_reading')

    if re.search(r'\b(will go wrong|going to fail|this will)\b', thought_lower):
        detected.append('fortune_telling')

    return detected

This isn't therapy — it's a prompting tool. The user confirms which distortions actually apply. But the pattern matching helps you learn to recognize them.

Step 3: Interactive CLI

def run_thought_record():
    print('=' * 60)
    print('  CBT Thought Record Journal')
    print('=' * 60)

    record = ThoughtRecord()
    record.situation = input('What happened? (Describe the situation):\n> ')

    print('\nWhat emotions did you feel? (rate 0-100)')
    print("Type emotion + rating, e.g. 'anxiety 80'. Empty line to finish.")
    while True:
        entry = input('> ')
        if not entry.strip():
            break
        parts = entry.rsplit(' ', 1)
        if len(parts) == 2 and parts[1].isdigit():
            record.emotions[parts[0]] = int(parts[1])

    record.automatic_thoughts = input('\nWhat went through your mind?\n> ')

    detected = detect_distortions(record.automatic_thoughts)
    if detected:
        print('\nPossible cognitive distortions detected:')
        for d in detected:
            print(f'  - {DISTORTIONS[d]}')
        confirm = input('\nWhich apply? (comma-separate, or all):\n> ')
        record.distortions = detected if confirm.strip() == 'all' else \
            [d.strip() for d in confirm.split(',') if d.strip() in DISTORTIONS]

    record.evidence_for = input('\nEvidence that supports the thought:\n> ')
    record.evidence_against = input('\nEvidence against the thought:\n> ')
    record.balanced_thought = input('\nA fairer, more balanced thought:\n> ')

    print('\nRe-rate your emotions now (0-100):')
    for emotion in record.emotions:
        new_rating = input(f'  {emotion} (was {record.emotions[emotion]}): ')
        if new_rating.isdigit():
            record.new_emotion_rating[emotion] = int(new_rating)

    return record

Step 4: Storage + Pattern Review

from pathlib import Path
from collections import Counter

class ThoughtRecordJournal:
    def __init__(self, filepath='thought_records.json'):
        self.filepath = Path(filepath)
        self.records = self._load()

    def _load(self):
        if self.filepath.exists():
            with open(self.filepath, 'r') as f:
                return json.load(f)
        return []

    def add(self, record: ThoughtRecord):
        self.records.append(record.to_dict())
        self._save()

    def _save(self):
        with open(self.filepath, 'w') as f:
            json.dump(self.records, f, indent=2)

    def review_patterns(self):
        all_distortions = []
        for r in self.records:
            all_distortions.extend(r.get('distortions', []))

        counts = Counter(all_distortions)
        print('\n--- Your Most Common Distortions ---')
        for dist, count in counts.most_common():
            print(f'  {count}x  {DISTORTIONS.get(dist, dist)}')

        print('\n--- Emotion Intensity Trend ---')
        for r in self.records[-10:]:
            for emo, rating in r.get('emotions', {}).items():
                new = r.get('new_emotion_rating', {}).get(emo, '?')
                print(f"  {r['date'][:10]}  {emo}: {rating} -> {new}")

Step 5: Putting It Together

def main():
    journal = ThoughtRecordJournal()
    print('CBT Thought Record Journal')
    print('1. New thought record')
    print('2. Review patterns')
    print('3. Export to CSV')
    choice = input('\nChoice: ')

    if choice == '1':
        record = run_thought_record()
        journal.add(record)
        print('\nThought record saved.')
    elif choice == '2':
        journal.review_patterns()

if __name__ == '__main__':
    main()

Why This Matters

I built a full CBT toolkit with 200+ free tools covering specific phobias, chronic illness, burnout, and more. The thought record is the foundation — once you can identify and reframe a cognitive distortion, you have a portable skill that works across every mental health challenge.

The toolkit is free and open source: CBT Toolkit on GitHub

The Science

CBT has one of the strongest evidence bases in mental health:

Anxiety disorders: 50-60% symptom reduction (Hofmann et al., 2012 meta-analysis of 269 studies)
Depression: equivalent to SSRI medication in mild-moderate cases (Cuijpers et al., 2013)
Insomnia: 70-80% improvement (CBT-I specifically)
PTSD: recommended first-line treatment by APA, NICE, and WHO

The thought record targets cognitive restructuring — the process of identifying, evaluating, and modifying distorted thinking patterns. It's the CBT equivalent of git bisect for your mind: systematically narrowing down where the bug (distortion) is.

Beyond the CLI

From here, you could extend this tool to:

Web app (Flask/FastAPI) with a nice UI for the 7-column table
Mobile app (React Native) with push reminders
NLP-powered distortion detection using a fine-tuned model
Pattern visualization with matplotlib showing emotion trends
Export to PDF for sharing with a therapist

The core data model and distortion detector stay the same — only the interface changes.

Takeaway

Building mental health tools is deeply rewarding. You're not just writing code — you're creating something that could help someone understand their own mind a little better. And the thought record is the perfect starting point: it's structured, evidence-based, and translates naturally into a data model.

If you found this helpful, check out the CBT Toolkit — 200+ free CBT tools for specific conditions, all open source.

Disclaimer: This tool is for self-help and education, not a replacement for professional therapy. If you're struggling, please reach out to a licensed therapist or a crisis line (988 in the US).

Build a Cognitive Distortion Detector in 60 Lines of Python

CBT Tools — Thu, 01 Oct 2026 01:02:03 +0000

Cognitive distortions are the mental shortcuts that lie to us. "I failed once, so I'll always fail." "Everyone is judging me." "If it's not perfect, it's worthless."

Aaron Beck identified 15+ of these patterns in the 1960s. They're the core target of Cognitive Behavioral Therapy (CBT). And they're surprisingly detectable with code — because distortions have linguistic signatures.

In this tutorial, I'll show you how to build a detector that identifies 10 cognitive distortions from a text input, in under 60 lines of Python. No ML model. No API key. Just pattern matching on the linguistic markers that therapists look for.

The 10 Distortions

Here are the patterns we'll detect, with their linguistic signatures:

Distortion	Signature	Example
All-or-Nothing	"always", "never", "completely", "total"	"I always mess up"
Overgeneralization	"always", "never", "every time"	"Every time I try, I fail"
Mental Filter	"only", "just", "nothing but"	"It was only the bad part"
Disqualifying Positive	"but", "doesn't count", "doesn't matter"	"She said I did well, but she was just being nice"
Mind Reading	"they think", "everyone knows", "people are"	"They think I'm stupid"
Fortune Telling	"will", "going to", "I'll never"	"I'll never get this job"
Magnification	"terrible", "awful", "disaster", "worst"	"This is a complete disaster"
Emotional Reasoning	"I feel", therefore it is	"I feel guilty, so I must be guilty"
Should Statements	"should", "must", "have to", "ought"	"I should be better at this"
Labeling	"I am a", "I'm a", "he is a"	"I'm a failure"

The Code

import re
from dataclasses import dataclass

@dataclass
class Distortion:
    name: str
    description: str
    patterns: list[str]
    intervention: str

DISTORTIONS = [
    Distortion("All-or-Nothing Thinking", "Seeing things in black-white categories",
        [r"(always|never|completely|totally|absolute)"],
        "Is it truly 100% one way? Look for the middle ground."),
    Distortion("Overgeneralization", "Viewing a single event as a never-ending pattern",
        [r"(everys*time|always|nevers*again)"],
        "One event ≠ a pattern. What's the evidence for 'every time'?"),
    Distortion("Mental Filter", "Focusing exclusively on negative aspects",
        [r"(only|just|nothings*but)"],
        "What positive aspects are you filtering out?"),
    Distortion("Disqualifying Positive", "Rejecting positive experiences as if they don't count",
        [r"(buts+(?:its+)?doesn'?ts+count|doesn'?ts+matter|justs+beings+nice)"],
        "Can you accept the positive at face value?"),
    Distortion("Mind Reading", "Assuming you know what others are thinking",
        [r"(theys+think|everyones+(?:think|know)|peoples+ares+thinking)"],
        "What's the evidence? Did they say it, or are you assuming?"),
    Distortion("Fortune Telling", "Predicting negative outcomes as fact",
        [r"(I'?lls+never|goings+tos+fail|wills+never)"],
        "Can you predict the future? What's a more likely outcome?"),
    Distortion("Magnification", "Exaggerating the importance of negatives",
        [r"(terrible|awful|disaster|catastrophe|worst|ends+ofs+thes+world)"],
        "How bad is it really, on a 1-10 scale?"),
    Distortion("Emotional Reasoning", "Assuming feelings reflect objective reality",
        [r"(Is+feels+w+.*?(?:so|therefore).*?(?:must|am|means))"],
        "Feelings are data, but not proof. What would evidence say?"),
    Distortion("Should Statements", "Rigid rules about how things 'should' be",
        [r"(should|must|haves+to|oughts+to|shouldn'?t)"],
        "Replace 'should' with 'prefer' or 'choose to'. What happens?"),
    Distortion("Labeling", "Defining yourself by a single event",
        [r"(I'?ms+as+w+|Is+ams+as+w+|hes+iss+as+w+|shes+iss+as+w+)"],
        "You are not one event. Describe the behavior, not the person."),
]

def detect_distortions(text: str) -> list[dict]:
    """Detect cognitive distortions in text. Returns list of matches."""
    text_lower = text.lower()
    results = []
    for d in DISTORTIONS:
        for pattern in d.patterns:
            matches = re.findall(pattern, text_lower)
            if matches:
                results.append({
                    "distortion": d.name,
                    "description": d.description,
                    "matched": matches,
                    "intervention": d.intervention,
                })
                break  # one match per distortion is enough
    return results

Testing It

thought = "I always mess up. They think I'm a failure. I should just quit."

for r in detect_distortions(thought):
    print(f"⚠️  {r['distortion']}")
    print(f"   Matched: {r['matched']}")
    print(f"   Reframe: {r['intervention']}")
    print()

Output:

⚠️  All-or-Nothing Thinking
   Matched: ['always']
   Reframe: Is it truly 100% one way? Look for the middle ground.

⚠️  Mind Reading
   Matched: ['they think']
   Reframe: What's the evidence? Did they say it, or are you assuming?

⚠️  Should Statements
   Matched: ['should']
   Reframe: Replace 'should' with 'prefer' or 'choose to'. What happens?

⚠️  Labeling
   Matched: ["i'm a failure"]
   Reframe: You are not one event. Describe the behavior, not the person.

4 distortions detected from one sentence. That's the power of linguistic pattern matching — distortions leave traces in language.

Why This Works

CBT therapists are trained to listen for these exact linguistic markers. The patterns above aren't arbitrary — they come from Beck's original taxonomy and decades of clinical literature. When someone says "I always fail," the word "always" is a linguistic marker of all-or-nothing thinking. When someone says "they think I'm stupid," the phrase "they think" is a marker of mind reading.

You don't need a neural network for this. The distortions are rule-based by definition — that's what makes them teachable to patients in therapy. If they were fuzzy ML predictions, CBT wouldn't work as a structured, manualized therapy.

Going Further

This 60-line detector is the core of a larger open-source toolkit I built — 36 free CBT tools covering procrastination patterns, attachment styles, safety behaviors, core beliefs, and more. The full toolkit includes:

A hosted API (free, no auth required)
Browser-based tools (no install)
PDF workbooks
A Python package

The full cognitive distortion detector with 15 patterns, severity scoring, and JSON API output is at: github.com/alexcColeDev/cbt-toolkit

The Honest Part

226 people have cloned this repo. 2 have starred it. 0 have paid for the optional $1 supporter tier.

I'm sharing this not as a success story, but as a build-in-public data point. The toolkit works — the detector above catches real distortions. But "works" and "converts" are different problems. I'm still figuring out the second one.

If you found this tutorial useful, the repo has 35 more tools like this. No signup, no email gate, no paywall. Just code.

Tags: python, tutorial, mentalhealth, opensource

I Shipped a Broken Download Link in My Open-Source Repo for 2 Weeks

CBT Tools — Mon, 28 Sep 2026 12:17:23 +0000

I Shipped a Broken Download Link in My Open-Source Repo for 2 Weeks

And I had no idea.

The Setup

I have an open-source mental health toolkit on GitHub — 36 free CBT (Cognitive Behavioral Therapy) tools, hosted on GitHub Pages. A few weeks ago, I transferred the repo from my old GitHub account 473185670 to a proper named account alexcoledev.

GitHub handled the transfer gracefully. The repo kept working. The Pages site kept serving. Clones kept coming. Everything looked fine.

Everything was not fine.

The Discovery

Two weeks later, I ran a SEO audit on all 47 of my GitHub Pages HTML files. The audit checked for:

Stale URLs pointing to the old 473185670.github.io domain
Broken og:image tags (the preview images shown when you share on Twitter/LinkedIn)
Canonical URL mismatches
JSON-LD structured data with wrong URLs

The result: 532 stale URLs across 47 pages.

532.

Every single og:image tag. Every canonical URL. Every BreadcrumbList JSON-LD entry. All pointing to a domain that 301-redirected to the new one — so they worked, but they weren't correct.

Why It Mattered

"It still redirects, so who cares?" — me, before I understood the problem.

Here's who cares:

1. Search engines. Google sees 473185670.github.io/cbt-toolkit/seo/cbt-for-anxiety.html and alexcoledev.github.io/cbt-toolkit/seo/cbt-for-anxiety.html as two different URLs with the same content. That is duplicate content. Even with a 301 redirect, it is not ideal — Google has to follow the redirect, and some SEO authority is lost in the hop.

2. Social media crawlers. When someone shared my tool on Twitter, the twitter:image tag pointed to https://473185670.github.io/cbt-toolkit/pinterest/pin1_cbt_benefits.png. Twitter's crawler followed the redirect and loaded the image — but slower. Sometimes it timed out. The preview card showed a broken image.

3. Structured data validators. Google's Rich Results Test flagged my BreadcrumbList JSON-LD because the item URLs redirected. Schema.org validators want the final URL, not a redirect.

4. Me, two weeks later. I wondered why my Bing ranking had dropped. It had not dropped because of the content — it had dropped because Bing was confused about which URL was canonical.

The Fix

One commit. 532 URL replacements across 47 files.

import os

old = '473185670.github.io'
new = 'alexcoledev.github.io'

for f in os.listdir('seo'):
    if f.endswith('.html'):
        path = os.path.join('seo', f)
        content = open(path).read()
        fixed = content.replace(old, new)
        if fixed != content:
            open(path, 'w').write(fixed)
            print(f'Fixed {f}')

532 stale URLs to 0 stale URLs. Canonical URLs correct. og:image pointing to the right domain. BreadcrumbList JSON-LD valid.

What I Should Have Done

1. Use a config file for the base URL. Instead of hardcoding 473185670.github.io in 47 HTML files, I should have used a single config and a build step.

2. Run the audit before the transfer. I should have searched for all occurrences of the old domain before transferring, not two weeks after.

3. Use relative URLs where possible. For internal links, ../img/pin1.png does not break when you transfer. Absolute URLs do.

4. Set up a redirect check in CI. A simple GitHub Action that runs grep -r '473185670' seo/ and fails if it finds anything. I now have this.

The Lesson

Repo transfers are not set it and forget it. GitHub redirects the repo, but every hardcoded URL in your Pages site, every og:image tag, every canonical URL, every JSON-LD entry — they all still point to the old domain. They work (301 redirect), but they are not correct.

532 stale URLs. Two weeks. Zero clue.

Run the audit. Use config. Use relative URLs. Check your og:image tags after any domain change.

⭐ If this helped, star the repo

If this post saved you an audit, star cbt-toolkit on GitHub. It helps others find these tools.

React with ❤️ if this helped — it boosts this post in the feed and helps others find it.

I build 36 free CBT mental health tools — no signup, no tracking, no paywall. This post is part of an honest build-in-public series about what goes wrong when you ship things.

How I Got 36 Free CBT Tools to #1 on Bing with 0 Budget

CBT Tools — Mon, 28 Sep 2026 10:07:49 +0000

I spent 30 days building 36 free cognitive behavioral therapy tools. Then I spent another 10 days doing SEO with zero budget. Here's what actually worked.

The Setup

36 tools. 8 interactive online, 28 in a downloadable ZIP. All vanilla JS, no framework, no backend, no signup. Hosted on GitHub Pages (free).

The tools work. The question was: how does anyone find them?

What I Tried First (And What Failed)

1. GitHub Discussions

I created 10 GitHub Discussions asking the community what tools they wanted. 0 responses. All 10 discussions sit at 0 comments.

GitHub Discussions are not a distribution channel. They're a support channel for repos that already have users.

2. Reddit

Posted in r/mentalhealth and r/selfhosted. Account got shadowbanned within 48 hours. Reddit's spam filter is aggressive against new accounts posting links.

Access does not equal visibility. Your account works. Your posts appear in your profile. But they're silently filtered from the feeds where anyone would see them.

3. Hashnode and Medium

Both Cloudflare-blocked my API calls. Hashnode returned 403. Medium returned 403. I could read the sites in a browser, but the publish APIs were blocked.

If you're building an automated publishing pipeline, test the API before you write the content.

What Actually Worked: GitHub Pages SEO

GitHub Pages gives you a free domain (username.github.io/repo), free hosting, and Google indexes it. The bottleneck wasn't building tools — it was making them findable.

Here's the 10-day sequence that got me to #1 on Bing for several long-tail terms:

Day 1-2: One SEO page per tool

I created 47 standalone SEO pages — one per tool, plus hub pages. Each page has:

A <title> tag under 60 chars
A meta description under 155 chars
A canonical URL
Open Graph tags for social sharing
Twitter Card tags

Day 3-4: Internal linking

Every tool page links to 2-3 related tools. 152 internal links total. This helps Google understand the site structure and distributes page authority.

Day 5: Sitemap.xml

51 URLs in sitemap.xml. Submitted to Google Search Console and Bing Webmaster Tools.

Day 6: robots.txt

User-agent: *
Allow: /
Sitemap: https://alexcoledev.github.io/cbt-toolkit/sitemap.xml
Crawl-delay: 1

Day 7-8: Structured data (JSON-LD)

This is the part that actually moves the needle for rich results.

Every page got 5 types of JSON-LD:

CollectionPage — tells Google this is a collection of tools
ItemList — structured list of the 8 interactive tools
FAQPage — 247 FAQ questions across 47 pages (5+ per page). FAQ rich results show directly in search results.
SoftwareApplication — marks each tool as a free HealthApplication
Organization — Knowledge Graph eligibility with sameAs links to GitHub, Dev.to, and Substack

Day 9: HowTo schema

3 how-to pages got HowTo JSON-LD with 21 total HowToStep entries. HowTo rich results show step-by-step instructions directly in search results.

Day 10: Organization Knowledge Graph (just shipped)

Added Organization JSON-LD with sameAs links to GitHub, Dev.to, and Substack. This makes the project eligible for Google's Knowledge Graph — the panel that appears on the right side of search results for known entities.

The Results

Metric	Before SEO	After 10 days
Stars	0	2
Clones (14d)	0	214
ZIP downloads	0	1
Bing ranking	unindexed	#1 for several long-tail terms

214 cloners. 2 stars. The conversion problem is real. People clone the repo but don't star it. They download the ZIP but don't come back.

But 214 cloners means 214 people found the tools. That's 214 more than before SEO.

What I Learned

1. SEO is free distribution

GitHub Pages + JSON-LD + sitemap costs $0. The only cost is time — about 10 days of evenings.

2. Structured data beats content quality for discovery

FAQ rich results show your answers directly in search results. Users click through less, but the ones who do are high-intent. HowTo rich results show your steps inline. These are the features that get you into the search result real estate that plain content can't.

3. The conversion funnel is: search then clone then (maybe) star

214 cloners and 2 stars means the bottleneck isn't discovery anymore. It's the README. The repo gets found, gets cloned, but the README doesn't convert cloners into stargazers.

That's the next problem.

4. Bing is easier than Google for new sites

Google took weeks to index. Bing indexed within days and ranked several pages #1 for long-tail terms. If you're launching a new static site, submit to Bing Webmaster Tools first.

The Tools

All 36 tools are free, no signup, run in your browser:

CBT Thought Record Tool — 7-step interactive thought record
Cognitive Distortion Checker — paste a thought, see which distortions apply
CBT for Anxiety + Grounding — 6 techniques + 5-4-3-2-1 grounding
CBT for Depression — behavioral activation scheduler
Mood Tracker — log mood, view trends

Plus 31 more. Full list at alexcoledev.github.io/cbt-toolkit.

The Takeaway

You don't need a marketing budget. You need:

A free host (GitHub Pages)
One SEO page per tool
JSON-LD structured data (FAQ + HowTo + SoftwareApplication + Organization)
A sitemap
Patience (10 days)

The tools were the easy part. Making them findable was the real work.

All 36 tools are open source: github.com/alexcoledev/cbt-toolkit

⭐ If this helped, star the repo

If you found this useful, please star cbt-toolkit on GitHub** ⭐

It helps others discover these 36 free CBT mental health tools.

React with ❤️ if this helped — it boosts this post in the feed and helps others find it.

v1.7.0 Release: 36 Free CBT Tools, Now One-Click Download

CBT Tools — Sun, 27 Sep 2026 11:03:16 +0000

v1.7.0 is live. GitHub Release →

What's in the box

36 free, interactive, privacy-first CBT (Cognitive Behavioral Therapy) tools — no signup, no backend, no tracking. Just open the HTML file in a browser.

The toolkit covers:

Anxiety — generalized anxiety, social anxiety, panic attacks, health anxiety, relationship anxiety
Mood — depression, burnout, low self-esteem, shame, grief & loss
Behavior — procrastination, perfectionism, OCD, ADHD, anger, body image
Trauma — PTSD, intrusive thoughts, imposter syndrome
Tech-specific — code review anxiety, debugging stress, incident response stress, on-call anxiety, production catastrophizing

Plus standalone detectors:

Cognitive Distortion Detector (15 distortions)
Core Belief Detector
Safety Behavior Detector
CBT Thought Record
Mood Tracker
Price Discrimination Detector

What's new in v1.7.0

One-click download

The release now includes a ZIP asset — . Download it, unzip, open . No needed.

This matters because 214 people cloned the repo but only 2 starred it. The clone-to-star gap told me something: people want the tools, not the repo. So now the tools are one click away.

$1 supporter option

I added a $1 Gumroad supporter page. Not a paywall — every tool remains free forever. It's for the person who used a tool, found it helpful, and wants to say thanks with a dollar.

This is the first unblocked revenue mechanism after trying:

RapidAPI (pricing feature disabled)
Stripe (requires business account setup)
npm (needs publisher auth)
aitopia.ai agent marketplace (3 agents in review for 286+ hours)

$1 Gumroad works because the account already exists and the API is open.

Free API still live

The CBT Thought Analyzer API is live on Render:

curl -X POST https://cbt-thought-analyzer.onrender.com/analyze   -H "Content-Type: application/json"   -d '{"text": "I always mess everything up"}'

Returns detected cognitive distortions with CBT reframes. Free, no auth.

The honest part

Revenue: $0. 214 cloners, 2 stars, 0 sales.

I'm not going to pretend the $1 supporter link will work. It might not. Developer tooling audiences are the hardest to monetize — they expect free, they value self-reliance, and a dollar feels like more friction than a star.

But the experiment is running. The release notification went out to watchers. The repo description has the supporter link. The README has it. This Dev.to post has it. Four touchpoints, one $1 ask.

If you cloned the toolkit and used a tool — even one — I'd love to know which one. Discussions are open.

I Added a $1 Supporter Option to My Open-Source Mental Health Toolkit. Here's What Happened.

CBT Tools — Sun, 27 Sep 2026 09:07:41 +0000

The setup

I've been building cbt-toolkit - 36 free mental health tools based on Cognitive Behavioral Therapy - for about 30 days now. The toolkit is open-source. Everything is free. No paywalls, no freemium, no "upgrade to pro."

A few days ago, 157 people had cloned the repo. 2 had starred it. 0 had paid for anything (because there was nothing to pay for).

I started wondering: what would happen if I added a $1 supporter option?

Not a subscription. Not a "buy me a coffee" button. Just a single Gumroad product: Support the CBT Toolkit for $1.

The hypothesis

The hypothesis was simple:

If 157 people found enough value to clone the repo, at least one might be willing to pay $1 to support continued development.

This is the lowest-friction monetization test possible:

$1 - less than a coffee
No account needed - Gumroad handles checkout
No recurring charge - one-time payment
No gate on the tools - everything stays free

The result (so far)

I added the $1 product 3 hours ago. I also added a small section to the README:

## Support the Toolkit

If these tools helped you, consider [supporting for $1](https://4043969836017.gumroad.com/l/supporter).
Every dollar goes toward keeping the tools free and ad-free.

Current stats:

GitHub clones: 157
GitHub stars: 2
$1 supporter purchases: 0
Gumroad product views: 0

Zero. Not even a view.

What I think is happening

I have a few hypotheses:

1. The CTA isn't visible enough. The README section is at the bottom. Most cloners probably never scroll that far.

2. Cloning is not commitment. People clone repos for many reasons - to read the code, to fork it, to learn from it, to never look at it again. Cloning is a low-friction action. Paying $1 is a higher-friction action, even at $1.

3. The audience is developers, not buyers. Developers who clone mental health tools are interested in the code, not necessarily in supporting the project. They might build their own version, or use it as reference, or never actually run it.

4. $1 is still a psychological barrier. Even $1 requires: opening Gumroad, entering payment info, completing checkout. That's 3-4 steps. Free is 0 steps.

What I'm trying next

I'm going to:

Move the CTA higher in the README (above the fold)
Write more build-in-public content about the experiment - transparency as a feature
Track the 24h data and report back honestly

The real question

The real question isn't "will anyone pay $1?" The real question is: what's the gap between "found this useful enough to clone" and "found this useful enough to pay $1 for"?

That gap is where the interesting work is. Understanding it tells you something about open-source sustainability, about the difference between use value and exchange value, about what "support" actually means.

I'll follow up in 24 hours with honest data.

Try the tools

If you're curious about the toolkit, here's a working example - the Cognitive Distortion Detector:

curl -X POST https://cbt-thought-analyzer.onrender.com/analyze \
  -H "Content-Type: application/json" \
  -d '{"text": "I always mess everything up. Nothing ever goes right for me."}'

Returns:

{
  "distortions": ["overgeneralization", "all-or-nothing thinking", "mental filter"],
  "count": 3
}

It's free. It'll stay free. The $1 is optional.

This is part of my build-in-public series on open-source sustainability. Follow along if you're interested in the honest data.

⭐ If this helped, star the repo

If you found this useful, please star cbt-toolkit on GitHub** ⭐

It helps others discover these 36 free CBT mental health tools.

React with ❤️ if this helped — it boosts this post in the feed and helps others find it.

5 Anti-Patterns I Fell Into Building 36 Mental Health Tools

CBT Tools — Sun, 27 Sep 2026 05:06:25 +0000

Over 30 days, I built 36 free cognitive behavioral therapy (CBT) tools with vanilla JavaScript. No frameworks, no backend, no dependencies. Every tool runs entirely in the browser.

The result: 157 GitHub cloners, 2 stars, 445 clones, $0 revenue.

Here are the 5 anti-patterns I fell into — so you do not have to.

Anti-Pattern 1: Building Before Validating Audience

I built 36 tools before asking anyone if they wanted them.

What happened: The tools are clinically sound (CBT is evidence-based, each tool maps to a specific cognitive distortion or behavioral pattern). But "clinically sound" and "something people will use" are different axes. I optimized for the first and assumed the second.

The fix: Validate with ONE tool first. Ship it. Watch what people do with it. Then build the second. I built 36 in parallel because the pattern was satisfying to execute — not because anyone asked for 36 tools.

The correct sequence is the reverse: market one tool, learn what resonates, build the next based on feedback.

Anti-Pattern 2: Optimizing for Completeness Over Distribution

I spent 30 days achieving "full coverage" — 24 CBT-for-X tools (OCD, ADHD, burnout, imposter syndrome, panic attacks, PTSD, shame, anger, body image, health anxiety, test anxiety, procrastination, perfectionism, social anxiety, insomnia, grief, low self-esteem, emotional drain, people-pleasing, rumination, attachment, cognitive distortions, core beliefs, safety behaviors) plus 24 niche funnels.

What happened: The content layer is comprehensive. The distribution layer has 92 Dev.to articles, 1 Substack subscriber, 0 paying customers. I built a library and forgot to build a readership.

The lesson: A complete product that nobody knows about has the same market impact as no product. I should have spent 20 days building and 10 days distributing — not 30 days building and 0 days distributing.

Completeness feels like progress. Distribution feels like risk. Your brain will always prefer the former.

Anti-Pattern 3: Treating Open Source as Distribution

MIT license is not a marketing strategy.

What happened: I published to GitHub with a clean README, MIT license, issue templates, CI workflow. 157 people cloned it. 2 starred it. The gap between "cloned" and "starred" is the gap between "useful" and "valuable enough to publicly endorse."

The 155 who cloned but did not star are not ungrateful — they are behaving exactly as cognitive behavioral therapy predicts. This is the action-intention gap: people intend to star (it costs nothing), but the action requires switching context, finding the repo, clicking a button. The friction is tiny but nonzero, and nonzero friction is enough.

I wrote a whole article analyzing this through a CBT lens. It is the most meta thing I have ever done.

The fix: A starred repo is a social signal. Ask for it directly. I added a CTA at the top of my README — "If this helped you, please star this repo" — and stars went from 1 to 2. That is a 100% increase. (It is also still 2.)

Anti-Pattern 4: Pursuing Every Platform Simultaneously

I created drafts for 28 platforms: Dev.to, Substack, Medium, LinkedIn, Hacker News, Product Hunt, Zhihu, Weibo, Xiaohongshu, Bilibili, Douban, Toutiao, Reddit, Threads, Mastodon, Bluesky, Nostr, Quora, Hashnode, TikTok, YouTube, Blogger, Jianshu, Tumblr, Pinterest, Instagram, X/Twitter, IndieHackers.

What happened: I published on 3. The other 25 drafts sit in a folder, each tailored to its platform's audience and format. I spent days writing platform-specific versions of the same content for platforms I never launched on.

The lesson: Breadth without depth equals zero engagement everywhere. I should have picked 2 platforms, published consistently for 30 days, measured, then expanded. Instead, I spread preparation across 28 and execution across 3.

Anti-Pattern 5: Monetization After Audience, Not Alongside

I waited for an audience before building monetization.

What happened: I now have 157 cloners and no way to convert them to revenue. The hosted API is free. The Gumroad products have 0 views. The RapidAPI listing has 1 free subscriber. I built the audience funnel and the revenue funnel as sequential phases — audience first, then monetization.

The correct approach is parallel: build the revenue path FIRST, so when traffic arrives, it can convert. I should have set up Stripe checkout on day 1, added a paid API tier on day 2, then spent 28 days driving traffic to a page that could actually capture value.

Where I am now: RapidAPI pricing is blocked at the platform level. The agent marketplace (aitopia.ai) has 3 agents in review for 275+ hours with no reviewer assigned. I am now building an independent Stripe + API key system on my own Render endpoint — the only unblocked direct revenue path.

It would have been easier to build this on day 1.

The Meta Anti-Pattern

All 5 anti-patterns share a root cause: I optimized for what felt productive instead of what moved the needle.

Building tools feels productive. Writing READMEs feels productive. Creating platform drafts feels productive. None of these are wrong — but they are all upstream of the actual bottleneck, which is distribution and conversion.

CBT has a name for this: productive procrastination. You do real, useful work to avoid the work that feels risky — asking people to pay, promoting your work, facing rejection.

I built 36 mental health tools. The irony is that I needed CBT to understand why I built 36 instead of shipping 1 and selling it.

What I am doing now: Building the revenue path (Stripe + API keys on the hosted endpoint), publishing consistently on 2 platforms instead of 28, and asking 157 cloners directly what they would pay for.

The tools are free. The lessons cost me 30 days. You can have both.

Links:

CBT Toolkit (36 free tools, vanilla JS)
Hosted CBT Analyzer API
Try the API: curl -X POST https://cbt-thought-analyzer.onrender.com/analyze -H "Content-Type: application/json" -d '{"text":"I always mess everything up"}'

157 People Cloned My Repo. 2 Starred It. Here is the Cognitive Bias Explanation.

CBT Tools — Sun, 27 Sep 2026 04:19:14 +0000

The Data

I have a GitHub repo with CBT (Cognitive Behavioral Therapy) mental health tools. As of today:

Metric	Count
Stars	2
Forks	0
Clones (unique)	157
Discussions	12

157 people cloned the repo. Only 2 starred it. That is a 1.3% star-to-clone ratio.

This is not a complaint. This is a data point — and it maps directly onto well-documented cognitive biases that CBT itself addresses.

Bias 1: Loss Aversion (Kahneman & Tversky, 1979)

The bias: People feel losses roughly 2x more intensely than equivalent gains.

How it applies: Starring a repo is a public action (visible on your profile). Cloning is private. The perceived "loss" of social visibility (what if people judge my stars? what if the repo turns out to be bad and I look foolish?) outweighs the perceived gain (supporting a creator, bookmarking).

The clone is the safe, private action. The star is the risky, public action. Loss aversion predicts exactly this pattern.

Bias 2: Default Bias / Status Quo Bias (Samuelson & Zeckhauser, 1988)

The bias: People disproportionately choose the default option.

How it applies: When you clone a repo, GitHub does NOT auto-star it. The default state after cloning is "not starred." Changing that default requires an additional action. Most people don't take it.

This is why GitHub's "You cloned this repo — would you like to star it?" prompt (which they tested and removed) would have dramatically increased star counts. It would have made starring the default.

Bias 3: The Bystander Effect (Darley & Latane, 1968)

The bias: The more people present, the less likely any individual is to act.

How it applies: 157 cloners see a repo with 2 stars. Each thinks "someone else will star it" or "it already has stars, my star doesn't matter." The diffusion of responsibility is proportional to the number of cloners.

Counter-intuitively, a repo with 0 stars might get MORE stars than a repo with 2 — because the first star feels impactful.

Bias 4: Action-Intention Gap (Gollwitzer, 1999)

The bias: People form intentions ("I should star this later") but never execute them.

How it applies: Cloning is immediate (you need the code now). Starring is deferred ("I'll star it after I try it"). The intention-to-action gap grows with time. 157 people cloned with the intention to evaluate later. Most never returned.

CBT addresses this with implementation intentions — "If I clone a repo, then I will star it immediately" — which Gollwitzer showed increases follow-through by 2-3x.

The CBT Toolkit Analyzes This

Here is the meta part: the CBT toolkit in the repo includes a cognitive distortion detector that identifies these exact thought patterns in text. If I fed "I'll star it later, I don't want to look foolish" into the detector, it would flag:

Minimization ("my one star doesn't matter")
Mind Reading ("people will judge my stars")
Should Statements ("I should star it later")
All-or-Nothing Thinking ("if I can't evaluate it fully, I won't star it")

The tools analyze the behavior of the people who clone but don't star. That is the most on-brand dogfooding I have ever done.

Try It Yourself

The CBT Thought Analyzer API is live:

curl -X POST https://cbt-thought-analyzer.onrender.com/analyze \
  -H "Content-Type: application/json" \
  -d '{"text":"I will star it later, my one star probably does not matter anyway"}'

Returns the detected distortions with CBT-based reframing suggestions.

What I Am Doing About It

Instead of complaining about the star-to-clone ratio, I applied the CBT principles:

Implementation intention (Gollwitzer): I added a "Star this repo if it helped you" call-to-action in the README. Make the action explicit and immediate.
Default bias counter: I created GitHub Discussions (lower-friction than issues) so the default action after cloning is "engage" not "leave silently."
Bystander effect counter: I showcase the 2 stars prominently in the README. Visible early adoption reduces diffusion of responsibility.
Loss aversion counter: I made the repo MIT-licensed and added a clear "what this is NOT" section. Reducing perceived risk of starring.

The Honest Part

I do not know if any of this will work. The 157 cloners might just be bots, scrapers, or people who cloned by accident. The 2 stars might be from friends doing me a favor.

But the analysis itself — applying cognitive bias research to open-source engagement data — is exactly the kind of cross-domain thinking that CBT encourages. And the toolkit I built to detect these biases in text is free, open-source, and has a live API.

If you are one of the 155 who cloned but did not star: no judgment. I understand the biases. But if you found this analysis useful, the star button is right there.

This is not therapy. If you are struggling with mental health, please reach out to a licensed professional. The CBT toolkit is an educational tool, not a substitute for professional care.

Why I Open-Sourced 36 Mental Health Tools Instead of Putting Them Behind a Paywall

CBT Tools — Sat, 26 Sep 2026 16:26:48 +0000

I built 36 cognitive behavioral therapy (CBT) tools. Then I gave them all away for free.

Not freemium. Not free with signup. MIT-licensed on GitHub, no backend, no tracking, no email gate.

157 developers have cloned the repo. I made $0.

Here is why I did it, and the tension I live with every day.

The decision

When I started building CBT tools I had two paths: paywall ($10-60/month like Woebot/Wysa/BetterHelp) or open-source (MIT, GitHub, no signup). I chose open-source.

1. The people who need it most cannot pay

CBT helps with anxiety, depression, procrastination, perfectionism. These conditions disproportionately affect people struggling financially. A $15/month subscription is a barrier for exactly the population that needs the tool.

2. Paywalling mental health creates a perverse incentive

When revenue depends on users staying subscribed, the incentive is to keep them in treatment, not to cure them. Open-source tools have no such incentive.

3. Open-source is the credibility layer

A paywalled mental health tool asks you to trust a black box. Open-source says: here is the code, the regex, the CBT theory. Verify it yourself. For mental health, transparency IS the feature.

4. The tools are not the business

The 36 tools are a funnel. The business is a hosted API (free tier + RapidAPI paid), a structured bundle ($4.99 Gumroad), and AI agents on a marketplace (3 submitted to aitopia.ai, in review 262h+).

The tension

I spent 30+ days building these tools. The API costs money to run. My time costs money. Free is only free for the user. The creator pays.

The open-source mental health space is full of abandoned projects. Good intentions, zero revenue, maintainer burnout. I see the graveyard every time I search GitHub for CBT tools.

So far: 157 cloners, 2 stars, $0 revenue, 24 reactions on Dev.to. People want the tools. They do not want to pay for them.

What I am trying next

Hosted API: curl -X POST https://cbt-thought-analyzer.onrender.com/analyze -H Content-Type:application/json -d {text:I always mess everything up}
Structured bundle: Gumroad $4.99 (organized curriculum + Notion templates + dev quickstart)
AI agents: 3 submitted to aitopia.ai, 70/30 split, in review 262h+
npm package: npm install cbt-detectors instead of copy-pasting

The honest answer

I do not know if open-source is the sustainable choice for mental health tools. I know it is the right choice. Ask me in 6 months.

Either way, the tools are out there. That part worked.

Links: GitHub alexcoledev/cbt-toolkit (36 tools, MIT). Free API POST https://cbt-thought-analyzer.onrender.com/analyze. Bundle gumroad.com/l/qwxzm $4.99.

I Benchmarked My Free CBT API Against 3 Commercial Mental Health Apps

CBT Tools — Sat, 26 Sep 2026 14:07:11 +0000

I built a free API that detects cognitive distortions in text using CBT (Cognitive Behavioral Therapy). It's live, it's open-source, and it costs $0. Then I looked at what $100+/week gets you from commercial mental health apps.

Here's the honest comparison.

The Free API

The CBT Thought Analyzer API is a rule-based cognitive distortion detector hosted on Render. You send it text, it returns the distortions found and a CBT reframe for each.

curl -X POST https://cbt-thought-analyzer.onrender.com/analyze \
  -H "Content-Type: application/json" \
  -d '{"text": "I failed this task so I must be a complete failure who will never succeed at anything"}'

Response:

{
  "output": "Detected 4 cognitive distortions: All-or-Nothing Thinking, Overgeneralization, Emotional Reasoning, Should Statements.",
  "distortions": [
    {
      "id": "allornothing",
      "name": "All-or-Nothing Thinking",
      "confidence": "medium",
      "matched_patterns": ["never", "complete failure"],
      "reframe": "Is there a middle ground? What counts as 'good enough' here? One mistake doesn't cancel everything else that's worked."
    }
  ]
}

It detects 10 distortions from Beck's cognitive model: All-or-Nothing Thinking, Overgeneralization, Mental Filter, Disqualifying the Positive, Jumping to Conclusions, Magnification/Minimization, Emotional Reasoning, Should Statements, Labeling, and Personalization/Blame.

What it is: a pattern-matching engine that identifies cognitive distortion patterns in text and suggests a CBT reframe.

What it is NOT: not a chatbot, not a therapist, not a diagnosis, not AI/ML. It's a rules engine built on 40 years of CBT research.

The Commercial Apps

Woebot

What it does: AI chatbot that uses CBT techniques in conversation
Cost: Free (with premium features)
Privacy: Conversations stored on their servers
Evidence: Published studies show modest efficacy for mild depression

Wysa

What it does: AI penguin chatbot with CBT exercises
Cost: Free basic, $73.99/year premium
Privacy: Server-side conversation processing
Evidence: NHS-approved in UK trials

BetterHelp

Cost: $65–$100/week
Privacy: HIPAA-compliant therapy platform
Evidence: Real therapist, real CBT — the gold standard

The Benchmark

Dimension	Free API	Woebot	Wysa	BetterHelp
Cost	$0	$0	$74/yr	$65–100/wk
Response format	JSON API	Chat	Chat	Video/text
Privacy	No data stored	Server-side	Server-side	HIPAA
Transparency	Open-source	Proprietary	Proprietary	N/A
Integration	REST API	App only	App only	Platform
Distortions detected	10	Conversational	Conversational	Therapist-led
CBT reframe	Yes (per distortion)	Yes (in chat)	Yes (in chat)	Yes (clinical)

Where the Free API Wins

1. Privacy. The API is stateless. No accounts, no sessions, no data retention. You send text, you get distortions, the server forgets. For mental health data, this matters enormously — the less data stored, the less data that can be breached.

2. Programmability. It's a REST API. You can integrate it into anything — a journaling app, a Slack bot, a VS Code extension that checks your commit messages for catastrophizing. Try doing that with Woebot.

3. Transparency. The detection rules are open-source. You can read exactly what patterns trigger "All-or-Nothing Thinking" and disagree with them. With commercial apps, the detection logic is a black box.

4. Cost. $0. Not freemium, not "free with ads," not "free for 7 days." Free.

Where the Commercial Apps Win

1. Conversational depth. A chatbot can have a back-and-forth. The API is one-shot: text in, distortions out. CBT works best as a dialogue, not a single analysis.

2. Clinical nuance. A licensed therapist (BetterHelp) can read between the lines, ask probing questions, and adapt. A rules engine matches patterns. It will never catch what a trained human catches.

3. Scope. The API only detects distortions. It doesn't treat depression, anxiety, trauma, or anything else. Commercial apps address broader mental health needs.

4. Accountability. BetterHelp has a licensed professional responsible for your care. The API has no accountability mechanism — it's a tool, not a provider.

The Honest Takeaway

These aren't competitors. They're different tools for different needs.

Building a mental health app? Use the free API as a building block. It handles distortion detection so you can focus on your product.
Mild negative thinking you want to understand? The API can identify your patterns in seconds.
Actual mental health condition? See a therapist. BetterHelp, local services, whatever you can access. A rules engine is not treatment.

The benchmark isn't "free API vs therapy." It's "can a free, transparent, privacy-preserving tool provide value in specific contexts?" And the answer is yes — for self-awareness, for integration, for education, for early pattern recognition before someone needs clinical care.

Try It

curl -X POST https://cbt-thought-analyzer.onrender.com/analyze \
  -H "Content-Type: application/json" \
  -d '{"text": "Everyone always rejects me. I should just give up. Nothing ever works out for me."}'

The source code is on GitHub. The API is free, has no rate limit (it's on a free Render tier, so it sleeps after 15 min of inactivity — first request takes ~15s to wake up), and stores zero data.

If you integrate it into something, I'd love to hear about it. And if you need more than distortion detection — please, talk to a professional.

I Submitted 3 AI Agents to a Marketplace. 258 Hours Later, Still Waiting.

CBT Tools — Sat, 26 Sep 2026 13:03:15 +0000

This is not a sponsored post. aitopia.ai has not reviewed or approved this article. I'm a developer waiting for a review queue, writing about the experience.