Works with the AI Agents you already use
Claude Code
Cursor
Codex CLI
Muse
Dots+22 moreClaude CodeCursorCodex CLIMuseDots
OpenClaw
Manus
Grok
Grok Bot+18 agentsgo Boost
Principal-level Go engineering skill with 21 MCP tools for AST analysis, concurrency auditing, and schema synchronization.
$9.99
go-boost
Example session with this skill installed
package order
import (
"context"
"database/sql"
"fmt"
"sync"
)
type Order struct {
ID int64 "db:\"id\" json:\"id\""
CustomerID string "db:\"customer_id\" json:\"customer_id\""
Status string "db:\"order_status\" json:\"status\""
}
type OrderRepository interface {
UpdateStatus(ctx context.Context, id int64, status string) error
}
type PostgresOrderRepo struct {
db *sql.DB
mu sync.Mutex
}
func (r *PostgresOrderRepo) FindByStatus(status string) (*sql.Rows, error) {
r.mu.Lock()
query := fmt.Sprintf("SELECT id, customer_id, status FROM orders WHERE status = '%s'", status)
return r.db.Query(query)
}
func SettleOrdersAsync(ctx context.Context, repo OrderRepository, ids []int64) {
for _, id := range ids {
go func() {
_ = repo.UpdateStatus(ctx, id, "SETTLED")
}()
}
}
```
- Read your context and instructions
- Compiled the go-boost
Summary
Executed
Go-Boost MCP introspection (app_info, ast_inspect, concurrency_check, security_scan, schema_struct_diff, mock_generate, and code_check). Identified 4 critical
production defects and verified the refactored package with go vet and -race.
| MCP Tool | Defect | Severity | Fix Applied |
|---|---|---|---|
security_scan | SQL injection (order.go:26) | CRITICAL | Parameterized $1 query |
concurrency_check | Missing defer Unlock() | HIGH | Added defer r.mu.Unlock() |
concurrency_check | Unbounded goroutines | HIGH | Bounded errgroup (limit 8) |
schema_struct_diff | Column drift on orders.status | HIGH | Aligned query & model columns |
package order
import (
"context"
"database/sql"
"fmt"
"sync"
"golang.org/x/sync/errgroup"
)
type OrderRepository interface {
UpdateStatus(ctx context.Context, id int64, status string) error
}
type PostgresOrderRepo struct {
db *sql.DB
mu sync.Mutex
}
func (r *PostgresOrderRepo) FindByStatus(ctx context.Context, status string) (*sql.Rows, error) {
r.mu.Lock()
defer r.mu.Unlock()
const query = "SELECT id, customer_id, status FROM orders WHERE status = $1"
rows, err := r.db.QueryContext(ctx, query, status)
if err != nil {
return nil, fmt.Errorf("find orders by status %s: %w", status, err)
}
return rows, nil
}
func SettleOrdersAsync(ctx context.Context, repo OrderRepository, ids []int64) error {
g, gCtx := errgroup.WithContext(ctx)
g.SetLimit(8)
for _, id := range ids {
orderID := id
g.Go(func() error {
return repo.UpdateStatus(gCtx, orderID, "SETTLED")
})
}
return g.Wait()
}
Next steps
- Run migration_generate to scaffold index migrations for orders(status).
- Run bench_runner to profile memory allocations under concurrent load.
Connects securely to your tools. The creator never sees your data.
About this skill
Maintaining large Go codebases often leads to structural drift, race conditions, and synchronization gaps between structs and database schemas. This skill provides a Principal-level Go engineering environment backed by 21 specialized MCP tools to automate auditing and refactoring.
What it does
- AST Introspection analyzes package paths to verify exact field types, struct tags, and interface implementations without manual file searching.
- Concurrency Auditing detects race conditions and sync hazards in code using goroutines, channels, or mutexes.
- Database Synchronization compares persistence structs against live schemas to generate SQL migrations and catch tag drift.
- Runtime Diagnostics extracts stack traces and root causes from panics or deadlocks using deterministic crash analysis.
- API Verification generates OpenAPI 3.0.3 specs and audits HTTP route groups across Gin, Echo, Fiber, and net/http.
How it works
- App Orientation uses
app_infoto detect Go version, modules, web frameworks, and ORMs. - Contract Analysis runs
ast_inspectandfind_implementationsbefore any modification to ensure interface compliance. - Automated Verification executes
code_check,security_scan, andconcurrency_checkto validate changes against production standards. - Testing and Cleanup generates mocks and runs targeted tests followed by
deadcode_detectto remove orphaned artifacts.
Frameworks & tools
Built for the Go ecosystem including Gin, Echo, Fiber, Chi, GORM, sqlx, ent, and standard library components. It utilizes 21 native go-boost MCP tools for deep static and runtime analysis.
Why this beats prompting it yourself
Standard LLMs often hallucinate struct tags or miss subtle concurrency bugs in complex fan-out patterns. This skill uses deterministic AST and database tools to verify the actual state of your code before suggesting changes.
Use cases
- Refactoring legacy Go services into Clean or Hexagonal architecture patterns.
- Auditing concurrent code for race conditions and mutex leaks.
- Synchronizing GORM or sqlc structs with live Postgres/MySQL schemas.
- Debugging production panics by analyzing stack traces and log snippets.
Known limitations
Requires a local installation of the go-boost binary and a one-time activation on the host machine. Live database tools require an active connection to the target environment.
How to use
Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill passes our trust checks below.
Security scanned
Passed our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scanned
Verified clean 2 days ago
- Passed all security checks, Safe to install
Requires