Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

thoughtbox:debug

/thoughtbox:debug

Porządkuje debugowanie, gdy pierwsze poprawki nie działają, zamiast losowych prób, po dwóch nieudanych próbach.

Repozytorium
thoughtbox ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.07.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format15 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.07.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Porządkuje debugowanie, gdy pierwsze poprawki nie działają, zamiast losowych prób, po dwóch nieudanych próbach.

Wyzwalacze z opisu

the first fix didnthis is behaving unexpectedlym stuckwhy is this happening

Argumenty

/thoughtbox:debug [problem description]
Oryginalny opis (EN)

Trigger when debugging something unexpected — a test failure, surprising behavior, production incident, or any situation where initial attempts aren't working. Prevents the common agent failure mode of trying random things when stuck. Use when "the first fix didn't work", "this is behaving unexpectedly", "I'm stuck", "why is this happening", or after 2+ failed attempts to fix something.

Jak działa

  1. Core Mechanic: The S-Register
  2. Phase 1: Initialize
  3. Phase 2: Plan-Act-Assess Loop
  4. Phase 3: Forced Reflection (S=2)
  5. Phase 4: Resolution
  6. Phase 5: Check Status
  7. When to Use This
  8. Key Principle
Sekcje z nagłówków SKILL.md, w oryginale · 143 linii, 597 słów
Podgląd SKILL.md
---
name: thoughtbox:debug
description: Trigger when debugging something unexpected — a test failure, surprising behavior, production incident, or any situation where initial attempts aren't working. Prevents the common agent failure mode of trying random things when stuck. Use when "the first fix didn't work", "this is behaving unexpectedly", "I'm stuck", "why is this happening", or after 2+ failed attempts to fix something.
argument-hint: "[problem description]"
user-invocable: true
allowed-tools: Read, Glob, Grep, Bash, Edit, Write, mcp__thoughtbox-cloud-run__thoughtbox_execute, mcp__thoughtbox-cloud-run__thoughtbox_search
---

# Thoughtbox Debug

Guided debugging workflow built on the Ulysses surprise-gated protocol.
Prevents reactive debugging spirals by forcing structured hypotheses after repeated surprises.

## Core Mechanic: The S-Register

The S-register (surprise counter) is the discipline mechanism. Each unexpected outcome increments S.
At S=2, stop and form a falsifiable hypothesis before continuing.
This breaks the "try something, doesn't work, try something else" spiral.

## Phase 1: Initialize

Start a debugging session. Define the problem and any constraints.

```javascript
async () => {
  return await tb.ulysses({
    operation: "init",
    problem: "$ARGUMENTS",
    constraints: [
      // Hard limits on what you can change
    ]
  });
}
```

This starts a session with S=0. State the problem precisely — vague problems produce vague debugging.

## Phase 2: Plan-Act-Assess Loop

Repeat this cycle for each investigation step.

### 2a. Plan with a pre-committed recovery action

Before investigating, declare what you will do AND what you will do if it fails.
The recovery action prevents post-hoc rationalization.

```javascript
async () => {
  return await tb.ulysses({
    operation: "plan",
    primary: "Check CI environment variables vs local .env",
    recovery: "If env vars match, check node version differences"
  });
}
```

### 2b. Execute

Run the primary action using whatever tools are needed (Read, Grep, Bash, etc.).
Gather evidence. Do not interpret yet.

### 2c. Assess the outcome

Report whether the result matched your expectation.

```javascript
async () => {
  return await tb.ulysses({
    operation: "outcome",
    assessment: "unexpected",  // or "expected"
    severity: "minor",         // or "major"
    details: "Env vars are identical — rules out config differences"
  });
}
```

- `"unexpected"` increments S. `"expected"` leaves S unchanged.
- Be honest. Calling a surprise "expected" defeats the protocol.

## Phase 3: Forced Reflection (S=2)

When S hits 2, the protocol blocks further plan operations until you reflect.
This is the mechanism that prevents spiraling.

```javascript
async () => {
  return await tb.ulysses({
    operation: "reflect",
    hypothesis: "The CI failure is caused by a timing race — the database isn't ready when tests start",
    falsification: "If adding a 5-second delay before test execution doesn't fix it, this hypothesis is false"
  });
}
```

Requirements for reflect:
- `hypothesis`: a specific, testable explanation (not "something is wrong with X")
- `falsification`: explicit criteria that would prove the hypothesis wrong

Reflection resets S to 0. Continue the Plan-Act-Assess loop with a focused hypothesis to test.

## Phase 4: Resolution

When the bug is found and fixed:

```javascript
async () => {
  return await tb.ulysses({
    operation: "complete",
    terminalState: "resolved",
    summary: "Root cause: async database seeding wasn't awaited in test setup. Fix: added await to beforeAll hook."
  });
}
```

Terminal states:
- `"resolved"` — root cause found and fixed
- `"abandoned"` — not worth further investigation
- `"deferred"` — understood but fix postponed (file an issue)

## Phase 5: Check Status

Query the current protocol state at any point.

```javascript
async () => {
  return await tb.ulysses({ operation: "status" });
}
// Returns: S value, consecutive surprises, hypothesis count, history
```

## When to Use This

**Use Ulysses when:**
- Your first attempt did not work
- The behavior is genuinely surprising
- You have been going in circles
- The problem involves multiple interacting systems
- You catch yourself thinking "let me just try one more thing"

**Skip for:**
- Simple typos or obvious errors
- Well-understood failure modes
- Quick fixes that work on first try

## Key Principle

When debugging feels frustrating — when you want to "just try this one more thing" —
that is exactly when S=2 reflection would help most.
The protocol forces you to stop guessing and start hypothesizing.

Wersje

W bazie nie ma innych skilli o nazwie thoughtbox:debug.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 1d36250ddc79 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100systematic-debugging
    Prowadzi przez czteroetapowe debugowanie każdego problemu technicznego, by unikać przypadkowych prób poprawek.
  • 100systematic-debugging
    Prowadzi czteroetapową analizę przyczyny, gdy test, build lub zachowanie programu nie są oczywiste, zamiast losowych prób poprawek.
  • 100debug
    Stosuje systematyczną metodę diagnozy dla błędów builda, testów, nietypowych zachowań agenta i błędów związanych z dryfem synchronizacji, a po dwóch nieudanych próbach przekazuje sprawę człowiekowi.
  • 100ask-codex
    Konsultuje z OpenAI Codex śledztwo, debugowanie lub przegląd kodu w trybie tylko do odczytu, jako ostatnia deska ratunku po czterech nieudanych próbach rozwiązania problemu.
  • 100debug
    Znajduje i dowodzi przyczyny awarii przed poprawką, a po dwóch nieudanych próbach kieruje sprawę do agenta architekta.
  • 100debugging-protocol
    Prowadzi debugowanie w czterech fazach (zrozumienie awarii, porównanie z działającymi przykładami, jedna hipoteza naraz, poprawka przyczyny i testy) z regułą Three Strikes i Iron Law bez poprawek bez badania.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.