[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M79ZAXN2133DTSMS3PFM02QM":3,"skill-same:01M79ZAXN2133DTSMS3PFM02QM":52},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":31,"commitSha":32,"skillDirectory":33,"forksCount":14,"repositoryHtmlUrl":34,"repositoryHomepageUrl":6,"ownerHtmlUrl":35,"ownerBlogUrl":36,"ownerDescription":37,"updatedAt":38,"install":39,"resources":51},"01M79ZAXN2133DTSMS3PFM02QM","go-performance-review",null,"Detect performance anti-patterns and apply optimization techniques in Go. Covers allocations, string handling, slice\u002Fmap preallocation, sync.Pool, benchmarking, and profiling with pprof. Use when checking performance, finding slow code, reducing allocations, profiling, or reviewing hot paths. Trigger examples: \"check performance\", \"find slow code\", \"reduce allocations\", \"benchmark this\", \"profile\", \"optimize Go code\". Not for: concurrency correctness (go-concurrency-review), general style (go-coding-standards).","kongnakornna\u002Fgolangapi","kongnakornna","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F10528904?v=4","01M79Z5JQPPV5CWQHXS235Q9MD","Kongnakorn Jantakun","01M79Z5JRHJJJ6PR2DGQS4P985",0,"MIT","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fgo-agent-skills\u002Fskills\u002F(safety)\u002Fgo-performance-review\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: go-performance-review\ndescription: >\n  Detect performance anti-patterns and apply optimization techniques in Go.\n  Covers allocations, string handling, slice\u002Fmap preallocation, sync.Pool,\n  benchmarking, and profiling with pprof. Use when checking performance,\n  finding slow code, reducing allocations, profiling, or reviewing hot\n  paths. Trigger examples: \"check performance\", \"find slow code\", \"reduce\n  allocations\", \"benchmark this\", \"profile\", \"optimize Go code\".\n  Not for: concurrency correctness (go-concurrency-review), general style\n  (go-coding-standards).\nuser-invocable: true\nlicense: MIT\ncompatibility: Designed for Claude Code or similar AI coding agents working on Go projects. Requires the Go toolchain. benchstat is optional, for comparing benchmark runs.\nallowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(gofmt:*) Bash(benchstat:*)\nmetadata:\n  author: eduardo-sl\n  version: \"1.2.1\"\n---\n\n# Go Performance Review\n\nProfile first, optimize second. Never optimize without a benchmark proving the problem.\n\n## 1. Allocation Reduction\n\n### Prefer `strconv` over `fmt` for primitive conversions:\n\n```go\n\u002F\u002F ✅ Good — zero allocations for simple conversions\ns := strconv.Itoa(42)\ns := strconv.FormatFloat(3.14, 'f', 2, 64)\n\n\u002F\u002F ❌ Bad — fmt.Sprintf allocates\ns := fmt.Sprintf(\"%d\", 42)\n```\n\n### Avoid unnecessary string-to-byte conversions:\n\n```go\n\u002F\u002F ✅ Good — use strings.Builder for concatenation\nvar b strings.Builder\nfor _, s := range parts {\n    b.WriteString(s)\n}\nresult := b.String()\n\n\u002F\u002F ❌ Bad — repeated concatenation allocates on every +\nresult := \"\"\nfor _, s := range parts {\n    result += s\n}\n```\n\n### Preallocate slices and maps when size is known:\n\n```go\n\u002F\u002F ✅ Good — single allocation\nusers := make([]User, 0, len(ids))\nfor _, id := range ids {\n    users = append(users, getUser(id))\n}\n\n\u002F\u002F ✅ Good — map with capacity hint\nlookup := make(map[string]User, len(users))\n\n\u002F\u002F ❌ Bad — repeated growing\nvar users []User \u002F\u002F starts at 0, grows via doubling\n```\n\n### Use `sync.Pool` for frequently allocated, short-lived objects:\n\n```go\nvar bufPool = sync.Pool{\n    New: func() interface{} {\n        return new(bytes.Buffer)\n    },\n}\n\nfunc process(data []byte) string {\n    buf := bufPool.Get().(*bytes.Buffer)\n    defer func() {\n        buf.Reset()\n        bufPool.Put(buf)\n    }()\n\n    buf.Write(data)\n    return buf.String()\n}\n```\n\n## 2. Hot Path Optimizations\n\n### Avoid interface conversions in tight loops:\n\n```go\n\u002F\u002F ✅ Good — concrete type in loop\nfunc sum(vals []int64) int64 {\n    var total int64\n    for _, v := range vals {\n        total += v\n    }\n    return total\n}\n\n\u002F\u002F ❌ Bad — interface{} causes boxing\u002Funboxing\nfunc sum(vals []interface{}) int64 { ... }\n```\n\n### Avoid `reflect` in performance-critical paths:\n\nIf you need reflection-like behavior at scale, use code generation\n(`go generate`, `stringer`, protocol buffers).\n\n### Reduce pointer chasing:\n\n```go\n\u002F\u002F ✅ Good — contiguous memory, cache-friendly\ntype Points struct {\n    X []float64\n    Y []float64\n}\n\n\u002F\u002F ❌ Slower — pointer chasing per element\ntype Points []*Point\n```\n\n## 3. Map Performance\n\n```go\n\u002F\u002F ✅ Use capacity hints\nm := make(map[string]int, expectedSize)\n\n\u002F\u002F ✅ For read-heavy concurrent access, use sync.Map\n\u002F\u002F But ONLY when keys are stable — sync.Map has higher overhead\n\u002F\u002F for writes than a mutex-protected map.\n\n\u002F\u002F ✅ For fixed key sets, consider using a slice with index mapping\n\u002F\u002F instead of a map.\n```\n\n## 4. Benchmarking\n\nALWAYS write benchmarks before and after optimization:\n\n```go\nfunc BenchmarkFoo(b *testing.B) {\n    \u002F\u002F Setup outside the loop\n    input := generateInput()\n\n    b.ResetTimer()\n    for i := 0; i \u003C b.N; i++ {\n        result = Foo(input) \u002F\u002F assign to package-level var to prevent elision\n    }\n}\n\n\u002F\u002F Package-level var prevents compiler from eliminating the call\nvar result string\n```\n\nRun benchmarks with memory profiling:\n\n```bash\ngo test -bench=BenchmarkFoo -benchmem -count=5 .\u002F...\n```\n\nCompare before\u002Fafter with `benchstat`:\n\n```bash\ngo test -bench=. -count=10 > old.txt\n# make changes\ngo test -bench=. -count=10 > new.txt\nbenchstat old.txt new.txt\n```\n\n## 5. Profiling\n\n### CPU profiling:\n\n```bash\ngo test -cpuprofile=cpu.prof -bench=BenchmarkFoo .\ngo tool pprof cpu.prof\n```\n\n### Memory profiling:\n\n```bash\ngo test -memprofile=mem.prof -bench=BenchmarkFoo .\ngo tool pprof -alloc_space mem.prof\n```\n\n### HTTP server profiling (import net\u002Fhttp\u002Fpprof):\n\n```go\nimport _ \"net\u002Fhttp\u002Fpprof\"\n\n\u002F\u002F Access at http:\u002F\u002Flocalhost:6060\u002Fdebug\u002Fpprof\u002F\ngo func() {\n    \u002F\u002F Bind to loopback only — never the public listener.\n    log.Println(http.ListenAndServe(\"localhost:6060\", nil))\n}()\n```\n\nImporting `net\u002Fhttp\u002Fpprof` registers its handlers on `http.DefaultServeMux`.\nIf the service also serves public traffic from `DefaultServeMux`, profiles,\ncommand line and goroutine stacks become world-readable. Always give pprof\nits own loopback or internal-network listener.\n\n## 6. High-Throughput Logging\n\n`log\u002Fslog` is the right default for most services. But when benchmarks show\nlogging is a bottleneck (high-frequency hot paths, >100k log lines\u002Fsec),\nconsider zero-allocation loggers.\n\n### When slog is not enough:\n\n```go\n\u002F\u002F slog allocates per log call — fine for most services\nslog.Info(\"request handled\",\n    slog.String(\"method\", method),\n    slog.Int(\"status\", status),\n)\n\n\u002F\u002F In hot paths where benchmarks prove logging is a bottleneck,\n\u002F\u002F use zap's zero-allocation core:\nlogger, _ := zap.NewProduction()\nlogger.Info(\"request handled\",\n    zap.String(\"method\", method),\n    zap.Int(\"status\", status),\n)\n\u002F\u002F zap avoids allocations by using a field pool and typed fields\n```\n\n### Decision tree:\n\n| Scenario | Logger |\n|---|---|\n| General service logging | `log\u002Fslog` (stdlib, zero dependencies) |\n| High-frequency hot path (>100k lines\u002Fsec) | `go.uber.org\u002Fzap` (zero-alloc) |\n| Extreme throughput with JSON | `github.com\u002Frs\u002Fzerolog` (zero-alloc JSON) |\n\n### Best of both worlds — use zap as slog backend:\n\n```go\n\u002F\u002F Use slog API everywhere, backed by zap's performance\nzapLogger, _ := zap.NewProduction()\nslogHandler := zapslog.NewHandler(zapLogger.Core(), nil)\nlogger := slog.New(slogHandler)\n\n\u002F\u002F Code uses standard slog API — can swap backend without changing callers\nlogger.Info(\"request handled\",\n    slog.String(\"method\", method),\n    slog.Int(\"status\", status),\n)\n```\n\n### Logging anti-patterns in hot paths:\n\n```go\n\u002F\u002F ❌ Bad — logging inside tight loop\nfor _, item := range millions {\n    slog.Info(\"processing item\", slog.String(\"id\", item.ID))\n    process(item)\n}\n\n\u002F\u002F ✅ Good — sample or batch log\nfor i, item := range millions {\n    process(item)\n    if i%10000 == 0 {\n        slog.Info(\"progress\", slog.Int(\"processed\", i), slog.Int(\"total\", len(millions)))\n    }\n}\n\n\u002F\u002F ✅ Good — log summary after loop\nslog.Info(\"batch complete\", slog.Int(\"count\", len(millions)))\n```\n\nNEVER switch loggers without a benchmark proving the need.\n`slog` is fast enough for the vast majority of Go services.\n\n## 7. Common Anti-Patterns\n\n| Anti-Pattern | Fix |\n|---|---|\n| `fmt.Sprintf` for simple int→string | `strconv.Itoa` |\n| String concatenation in loop | `strings.Builder` |\n| Slice without preallocation | `make([]T, 0, n)` |\n| Map without capacity hint | `make(map[K]V, n)` |\n| `regexp.Compile` inside function | Compile once at package level |\n| `json.Marshal` in hot path | Use code-gen (`easyjson`, `sonic`) |\n| Logging in tight loop | Batch or sample |\n| `defer` in very tight inner loop | Manual cleanup (rare, benchmark first) |\n\n## Important Caveat\n\nMost Go code is not performance-critical. Readability and correctness ALWAYS\ntake priority over micro-optimizations. Only apply these patterns when:\n\n1. A benchmark proves this code path is a bottleneck\n2. The optimization is significant (>10% improvement)\n3. The resulting code remains readable and maintainable\n\nPremature optimization is still the root of all evil, even in Go.\n","# Go Performance Review\n\nProfile first, optimize second. Never optimize without a benchmark proving the problem.\n\n## 1. Allocation Reduction\n\n### Prefer `strconv` over `fmt` for primitive conversions:\n\n```go\n\u002F\u002F ✅ Good — zero allocations for simple conversions\ns := strconv.Itoa(42)\ns := strconv.FormatFloat(3.14, 'f', 2, 64)\n\n\u002F\u002F ❌ Bad — fmt.Sprintf allocates\ns := fmt.Sprintf(\"%d\", 42)\n```\n\n### Avoid unnecessary string-to-byte conversions:\n\n```go\n\u002F\u002F ✅ Good — use strings.Builder for concatenation\nvar b strings.Builder\nfor _, s := range parts {\n    b.WriteString(s)\n}\nresult := b.String()\n\n\u002F\u002F ❌ Bad — repeated concatenation allocates on every +\nresult := \"\"\nfor _, s := range parts {\n    result += s\n}\n```\n\n### Preallocate slices and maps when size is known:\n\n```go\n\u002F\u002F ✅ Good — single allocation\nusers := make([]User, 0, len(ids))\nfor _, id := range ids {\n    users = append(users, getUser(id))\n}\n\n\u002F\u002F ✅ Good — map with capacity hint\nlookup := make(map[string]User, len(users))\n\n\u002F\u002F ❌ Bad — repeated growing\nvar users []User \u002F\u002F starts at 0, grows via doubling\n```\n\n### Use `sync.Pool` for frequently allocated, short-lived objects:\n\n```go\nvar bufPool = sync.Pool{\n    New: func() interface{} {\n        return new(bytes.Buffer)\n    },\n}\n\nfunc process(data []byte) string {\n    buf := bufPool.Get().(*bytes.Buffer)\n    defer func() {\n        buf.Reset()\n        bufPool.Put(buf)\n    }()\n\n    buf.Write(data)\n    return buf.String()\n}\n```\n\n## 2. Hot Path Optimizations\n\n### Avoid interface conversions in tight loops:\n\n```go\n\u002F\u002F ✅ Good — concrete type in loop\nfunc sum(vals []int64) int64 {\n    var total int64\n    for _, v := range vals {\n        total += v\n    }\n    return total\n}\n\n\u002F\u002F ❌ Bad — interface{} causes boxing\u002Funboxing\nfunc sum(vals []interface{}) int64 { ... }\n```\n\n### Avoid `reflect` in performance-critical paths:\n\nIf you need reflection-like behavior at scale, use code generation\n(`go generate`, `stringer`, protocol buffers).\n\n### Reduce pointer chasing:\n\n```go\n\u002F\u002F ✅ Good — contiguous memory, cache-friendly\ntype Points struct {\n    X []float64\n    Y []float64\n}\n\n\u002F\u002F ❌ Slower — pointer chasing per element\ntype Points []*Point\n```\n\n## 3. Map Performance\n\n```go\n\u002F\u002F ✅ Use capacity hints\nm := make(map[string]int, expectedSize)\n\n\u002F\u002F ✅ For read-heavy concurrent access, use sync.Map\n\u002F\u002F But ONLY when keys are stable — sync.Map has higher overhead\n\u002F\u002F for writes than a mutex-protected map.\n\n\u002F\u002F ✅ For fixed key sets, consider using a slice with index mapping\n\u002F\u002F instead of a map.\n```\n\n## 4. Benchmarking\n\nALWAYS write benchmarks before and after optimization:\n\n```go\nfunc BenchmarkFoo(b *testing.B) {\n    \u002F\u002F Setup outside the loop\n    input := generateInput()\n\n    b.ResetTimer()\n    for i := 0; i \u003C b.N; i++ {\n        result = Foo(input) \u002F\u002F assign to package-level var to prevent elision\n    }\n}\n\n\u002F\u002F Package-level var prevents compiler from eliminating the call\nvar result string\n```\n\nRun benchmarks with memory profiling:\n\n```bash\ngo test -bench=BenchmarkFoo -benchmem -count=5 .\u002F...\n```\n\nCompare before\u002Fafter with `benchstat`:\n\n```bash\ngo test -bench=. -count=10 > old.txt\n# make changes\ngo test -bench=. -count=10 > new.txt\nbenchstat old.txt new.txt\n```\n\n## 5. Profiling\n\n### CPU profiling:\n\n```bash\ngo test -cpuprofile=cpu.prof -bench=BenchmarkFoo .\ngo tool pprof cpu.prof\n```\n\n### Memory profiling:\n\n```bash\ngo test -memprofile=mem.prof -bench=BenchmarkFoo .\ngo tool pprof -alloc_space mem.prof\n```\n\n### HTTP server profiling (import net\u002Fhttp\u002Fpprof):\n\n```go\nimport _ \"net\u002Fhttp\u002Fpprof\"\n\n\u002F\u002F Access at http:\u002F\u002Flocalhost:6060\u002Fdebug\u002Fpprof\u002F\ngo func() {\n    \u002F\u002F Bind to loopback only — never the public listener.\n    log.Println(http.ListenAndServe(\"localhost:6060\", nil))\n}()\n```\n\nImporting `net\u002Fhttp\u002Fpprof` registers its handlers on `http.DefaultServeMux`.\nIf the service also serves public traffic from `DefaultServeMux`, profiles,\ncommand line and goroutine stacks become world-readable. Always give pprof\nits own loopback or internal-network listener.\n\n## 6. High-Throughput Logging\n\n`log\u002Fslog` is the right default for most services. But when benchmarks show\nlogging is a bottleneck (high-frequency hot paths, >100k log lines\u002Fsec),\nconsider zero-allocation loggers.\n\n### When slog is not enough:\n\n```go\n\u002F\u002F slog allocates per log call — fine for most services\nslog.Info(\"request handled\",\n    slog.String(\"method\", method),\n    slog.Int(\"status\", status),\n)\n\n\u002F\u002F In hot paths where benchmarks prove logging is a bottleneck,\n\u002F\u002F use zap's zero-allocation core:\nlogger, _ := zap.NewProduction()\nlogger.Info(\"request handled\",\n    zap.String(\"method\", method),\n    zap.Int(\"status\", status),\n)\n\u002F\u002F zap avoids allocations by using a field pool and typed fields\n```\n\n### Decision tree:\n\n| Scenario | Logger |\n|---|---|\n| General service logging | `log\u002Fslog` (stdlib, zero dependencies) |\n| High-frequency hot path (>100k lines\u002Fsec) | `go.uber.org\u002Fzap` (zero-alloc) |\n| Extreme throughput with JSON | `github.com\u002Frs\u002Fzerolog` (zero-alloc JSON) |\n\n### Best of both worlds — use zap as slog backend:\n\n```go\n\u002F\u002F Use slog API everywhere, backed by zap's performance\nzapLogger, _ := zap.NewProduction()\nslogHandler := zapslog.NewHandler(zapLogger.Core(), nil)\nlogger := slog.New(slogHandler)\n\n\u002F\u002F Code uses standard slog API — can swap backend without changing callers\nlogger.Info(\"request handled\",\n    slog.String(\"method\", method),\n    slog.Int(\"status\", status),\n)\n```\n\n### Logging anti-patterns in hot paths:\n\n```go\n\u002F\u002F ❌ Bad — logging inside tight loop\nfor _, item := range millions {\n    slog.Info(\"processing item\", slog.String(\"id\", item.ID))\n    process(item)\n}\n\n\u002F\u002F ✅ Good — sample or batch log\nfor i, item := range millions {\n    process(item)\n    if i%10000 == 0 {\n        slog.Info(\"progress\", slog.Int(\"processed\", i), slog.Int(\"total\", len(millions)))\n    }\n}\n\n\u002F\u002F ✅ Good — log summary after loop\nslog.Info(\"batch complete\", slog.Int(\"count\", len(millions)))\n```\n\nNEVER switch loggers without a benchmark proving the need.\n`slog` is fast enough for the vast majority of Go services.\n\n## 7. Common Anti-Patterns\n\n| Anti-Pattern | Fix |\n|---|---|\n| `fmt.Sprintf` for simple int→string | `strconv.Itoa` |\n| String concatenation in loop | `strings.Builder` |\n| Slice without preallocation | `make([]T, 0, n)` |\n| Map without capacity hint | `make(map[K]V, n)` |\n| `regexp.Compile` inside function | Compile once at package level |\n| `json.Marshal` in hot path | Use code-gen (`easyjson`, `sonic`) |\n| Logging in tight loop | Batch or sample |\n| `defer` in very tight inner loop | Manual cleanup (rare, benchmark first) |\n\n## Important Caveat\n\nMost Go code is not performance-critical. Readability and correctness ALWAYS\ntake priority over micro-optimizations. Only apply these patterns when:\n\n1. A benchmark proves this code path is a bottleneck\n2. The optimization is significant (>10% improvement)\n3. The resulting code remains readable and maintainable\n\nPremature optimization is still the root of all evil, even in Go.\n",{"name":5,"license":15,"metadata":24,"description":27,"allowed-tools":28,"compatibility":29,"user-invocable":30},{"author":25,"version":26},"eduardo-sl","1.2.1","Detect performance anti-patterns and apply optimization techniques in Go. Covers allocations, string handling, slice\u002Fmap preallocation, sync.Pool, benchmarking, and profiling with pprof. Use when checking performance, finding slow code, reducing allocations, profiling, or reviewing hot paths. Trigger examples: \"check performance\", \"find slow code\", \"reduce allocations\", \"benchmark this\", \"profile\", \"optimize Go code\". Not for: concurrency correctness (go-concurrency-review), general style (go-coding-standards).\n","Read Edit Write Glob Grep Bash(go:*) Bash(gofmt:*) Bash(benchstat:*)","Designed for Claude Code or similar AI coding agents working on Go projects. Requires the Go toolchain. benchstat is optional, for comparing benchmark runs.",true,"main","19f4d52a98d557f3a645a2cfbbeb5bd54f28831d",".github\u002Fskills\u002Fgo-agent-skills\u002Fskills\u002F(safety)\u002Fgo-performance-review","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi","https:\u002F\u002Fgithub.com\u002Fkongnakornna","http:\u002F\u002Fcmoniot.trueddns.com:52160","Technical Skills and Expertise\r\nLanguages and Frameworks\r\nFrontend: HTML, JavaScript, TypeScript, React, Vue, Angular, Next.js\r\nBackend: Node.js,Python,Golang","2026-10-06 23:01:46",{"source":8,"skillName":5,"commands":40,"prompt":50,"zipAvailable":30},[41,44,47],{"tool":42,"command":43},"npx","npx skills add kongnakornna\u002Fgolangapi --skill go-performance-review",{"tool":45,"command":46},"bunx","bunx skills add kongnakornna\u002Fgolangapi --skill go-performance-review",{"tool":48,"command":49},"pnpm","pnpm dlx skills add kongnakornna\u002Fgolangapi --skill go-performance-review","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fgo-agent-skills\u002Fskills\u002F(safety)\u002Fgo-performance-review\u002FSKILL.md",[],[53,61,68,75,82,89],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":19},"01M7A0M9RJJ3383VEFYKABWV15","tb-writing-plans","Use when you have a spec or requirements for a multi-step task, before touching code","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-writing-plans\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":67,"publishedAt":19},"01M7A0M4JKY4DEDRP1CBHT00WV","tb-using-git-worktrees","Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-using-git-worktrees\u002FSKILL.md",[],[],{"skillNo":69,"name":70,"nameZh":6,"description":71,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":72,"categories":73,"keywords":74,"publishedAt":19},"01M7A0KZ5HRAQAAT2KXR6146Q7","tb-test-driven-development","Use when implementing any feature or bugfix, before writing implementation code","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-test-driven-development\u002FSKILL.md",[],[],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M7A0KW92W3F18E2MRP8H62P2","tb-subagent-driven-development","Use when executing implementation plans with independent tasks in the current session","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-subagent-driven-development\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M7A0KKYQCHYYRHA5J5BAP24M","tb-scrutinize","Outsider-perspective end-to-end review of a plan, PR, or code change. First questions intent and whether a simpler\u002Fmore elegant approach would achieve the same goal, then traces the actual code path (not just the diff) to verify the change does what it claims. Output is concise, actionable, and every call carries its rationale. Trigger on \u002Ftb-scrutinize and proactively whenever the user asks to review, audit, sanity-check, or get a second opinion on a plan, PR, diff, design doc, or proposed code change.","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-scrutinize\u002FSKILL.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":57,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"publishedAt":19},"01M7A0KFDR1V3RW7SW1XNHP82P","tb-requesting-code-review","Use when completing tasks, implementing major features, or before merging to verify work meets requirements","https:\u002F\u002Fgithub.com\u002Fkongnakornna\u002Fgolangapi\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftb-requesting-code-review\u002FSKILL.md",[],[]]