think-in-code
/think-in-code
Use when analyzing multiple files, auditing a codebase, scanning dependencies, or counting lines -- one Bash pipeline beats N sequential Read calls.
- Author
- fusengine ↗
- Repository
- agents ↗
- Licence
- MIT
- Last repository change
- 12.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when analyzing multiple files, auditing a codebase, scanning dependencies, or counting lines -- one Bash pipeline beats N sequential Read calls.
Arguments
/think-in-code [pattern] [scope]
Original author description
Use when analyzing multiple files, auditing a codebase, scanning dependencies, or counting lines -- one Bash pipeline beats N sequential Read calls.
How it works
- Principle
- 5 Runnable Patterns
- Anti-Pattern
- Before / After
SKILL.md preview
---
name: think-in-code
description: Use when analyzing multiple files, auditing a codebase, scanning dependencies, or counting lines -- one Bash pipeline beats N sequential Read calls.
argument-hint: "[pattern] [scope]"
keywords:
- analyze multiple files
- audit codebase
- find all
- scan dependencies
- count lines
- list files matching
- bulk read
user-invocable: false
---
<objective>
Think-in-Code replaces wasteful multi-Read loops with a single compact shell pipeline whenever the task is "for each file in a set, compute/extract X, then aggregate" -- file-size audits, multi-file symbol grep, dependency listing with versions, error-log scanning, lines-of-code-by-extension. Reserve `Read` for targeted inspection of one specific file already known to matter.
The reduction is typically ~60x in tokens consumed versus reading each file individually and tallying manually.
</objective>
# Think-in-Code Skill
## Principle
**1 Bash script = N Read calls avoided.**
When you'd read 10 files sequentially to extract a summary, you waste tokens loading full contents into context. Instead: 1 shell pipeline returns the compact aggregated result.
Heuristic: if your task is "for each file in set, compute/extract X, then aggregate" → write the script. Reserve Read for *targeted inspection* of a specific file you already know matters.
## 5 Runnable Patterns
### 1. File size audit (files over `FUSE_SOLID_MAX_LINES`)
```bash
find . -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.php" \) \
-not -path "*/node_modules/*" -not -path "*/vendor/*" \
| xargs wc -l 2>/dev/null \
| awk -v max="${FUSE_SOLID_MAX_LINES:?set to the hook ceiling}" '$1 > max && $2 != "total" {print $1, $2}' \
| sort -rn | head -20
```
### 2. Multi-grep symbols (compact JSON)
```bash
rg --json -g '*.ts' -g '*.tsx' 'export (function|class|const) (\w+)' src/ \
| jq -r 'select(.type=="match") | "\(.data.path.text):\(.data.line_number) \(.data.lines.text)"' \
| head -50
```
### 3. Dependencies with versions
```bash
# Node
jq -r '.dependencies, .devDependencies | to_entries[] | "\(.key)@\(.value)"' package.json 2>/dev/null
# PHP
jq -r '.require, ."require-dev" | to_entries[] | "\(.key)@\(.value)"' composer.json 2>/dev/null
```
### 4. Error log scan
```bash
grep -rEn 'ERROR|FATAL|Exception|panic:|stack trace' \
--include="*.log" logs/ 2>/dev/null \
| tail -30
```
### 5. Lines of code by extension
```bash
find . -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.py" -o -name "*.php" \) \
-not -path "*/node_modules/*" -not -path "*/vendor/*" -not -path "*/.git/*" \
-exec wc -l {} + \
| awk '{ext=$2; sub(/.*\./,"",ext); sum[ext]+=$1} END {for (e in sum) print sum[e], e}' \
| sort -rn
```
## Anti-Pattern
**Do NOT** Read 10 files sequentially to count their lines, list their exports, or check their size. That is ~6KB context per file = ~60KB wasted for a result that fits in 1KB.
```
WRONG: Read(f1.ts) → Read(f2.ts) → ... → Read(f10.ts) → manual tally
RIGHT: Bash(find ... | xargs wc -l | awk ...) → 1 compact table
```
## Before / After
**Task:** "Find files over `FUSE_SOLID_MAX_LINES` in `src/`."
- Before: 10 × Read full file → ~60KB tokens consumed, then mental wc.
- After: 1 × `find src -name '*.ts' | xargs wc -l | awk -v m="${FUSE_SOLID_MAX_LINES:-100}" '$1>m'` → ~1KB result.
**~60× reduction. Use the script.**
Versions
The database has no other skills named think-in-code.
Database snapshot: 13.11.2026 · package version 23f2a0cbf498 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100code-comments
Extract comment locations from code files for analysis. Use when cleaning comments, auditing documentation, or analyzing comment patterns across languages. - 92write-script-bash
MUST use when writing Bash scripts. - 100code-stats
Analyzes code files and reports statistics including line counts, file counts by extension, and total size. Use this skill whenever the user wants to understand the composition of a codebase - asking about "how many lines of code", "what file types exist", "code distribution",… - 90bash-script
Use when writing or editing a Bash script (a `.sh` file or one with a Bash shebang). Covers the template, conventions, and required patterns. - 95bash-linux
Bash and Linux/macOS shell patterns - operators, files, processes, text tools, scripts. Use for shell work on Unix.