agent-skills

Operationalising the data side of a RAG system — source enumeration, parsing, embedding batches, dedup, tombstone deletes, incremental git-SHA updates, schema migrations, observability. Use this skill when setting up or running the long-lived ingestion job over multiple repos.

CI on Google Cloud — Cloud Build, Artifact Registry, vulnerability scanning, and Cloud Deploy for progressive rollouts. Covers Workload Identity Federation from external CI. Use this skill when wiring image builds and deploys to a GKE service on GCP, or auditing an existing GCP-side pipeline.

Observability for Spring Boot on GCP — JSON logs to Cloud Logging, OpenTelemetry traces to Cloud Trace, Micrometer metrics to Managed Prometheus, correlation IDs, and SLOs. Use this skill when adding telemetry to a Spring Boot service or debugging a production incident.

Chip-flow ("chip") analysis for Taiwan-listed stocks — tracking the three major institutions (foreign, investment trust, dealer), margin trading (financing/short-selling), TDCC shareholder concentration, and "main force" broker activity. Helps retail investors read the supply-side of a stock to time entries and exits.

Trend identification for Taiwan-listed stocks — Dow theory structure (HH/HL vs LH/LL), multi-timeframe alignment, strength and phase, pullback vs reversal. Use this skill to answer "is this stock in an uptrend or downtrend, and how strong?" before any entry / exit decision.

RAG infrastructure on GCP — Vertex AI Vector Search, AlloyDB AI, pgvector on Cloud SQL, Firestore vector, Vertex AI RAG Engine; embedding models; Document AI; IAM and cost. Use this skill when sizing or selecting the GCP RAG stack for a Spring/Java backend.

Knowledge-graph RAG for multi-microservice projects — modelling services, endpoints, events, dependencies as a graph; extracting edges from OpenAPI / Pub-Sub / Maven; hybrid graph + vector retrieval. Use this skill when "talk to my codebase" RAG misses cross-service relationships.

Deploying containerised services to GKE — Autopilot vs Standard, Workload Identity, Deployment/Service/Ingress manifests, GCLB, HPA, PDB, and rolling updates. Use this skill when shipping a service to GKE or hardening an existing GKE workload for production.

Connecting Spring Boot to Cloud SQL (PostgreSQL/MySQL) on GCP — Cloud SQL Java Connector vs Auth Proxy, IAM database authentication, HikariCP sizing, private IP, and read replicas. Use this skill when wiring a Spring Boot service to Cloud SQL on GKE or Cloud Run, or when scaling an existing setup.

Firestore in Native Mode from Spring Boot via Spring Cloud GCP — document modelling, repositories, transactions, security rules vs server-side access, and when not to choose Firestore. Use this skill when using Firestore as the primary or auxiliary store for a Spring backend.

Google Cloud Pub/Sub from Spring Boot via Spring Cloud GCP — publishing, pull/push subscribers, ack/nack semantics, ordering keys, dead-letter topics, exactly-once delivery. Use this skill when a Spring service publishes or consumes Pub/Sub messages.

RAG inside a Spring Boot service with Spring AI — VectorStore (pgvector / Vertex AI), DocumentReader, Embedding clients, RetrievalAugmentation / QuestionAnswerAdvisor, exposing RAG over REST. Use this skill when the RAG component is itself a Spring Boot microservice.

Spring Boot fundamentals — project structure, auto-configuration, profiles, configuration binding, Actuator, and graceful shutdown. Use this skill when starting a Spring Boot service, choosing between Spring MVC and WebFlux, wiring beans, or hardening a Boot app for production.

Portfolio construction guide — asset allocation, diversification, rebalancing, personal risk-tolerance assessment, the core-satellite strategy, a simplified Kelly criterion, and performance tracking. For retail investors graduating from single-stock picking to systematic portfolio management.

Fundamental analysis for Taiwan-listed stocks — financial-statement reading, revenue momentum, industry structure, and dividend policy as filters. Covers the MOPS data source, monthly/quarterly/annual report timing, key ratios, selection frameworks (yield, growth, value), and common red flags. Concept- oriented; not tied to a specific tool.

Quantitative investing for Taiwan-listed stocks — backtest framework design, classic factor models (value, momentum, quality, low volatility), strategy development workflow, performance metrics, overfitting and survivorship bias, and post-go-live discipline. Concept-first; pseudo-code examples are language-agnostic (Python / Go / R).

Technical analysis for Taiwan-listed stocks — candlestick patterns, moving averages, MACD, RSI, KD, Bollinger Bands, volume-price relationships, support / resistance, and a multi-indicator confluence framework. Concept- focused; pairs best with fundamental and chip-flow analysis.

Conceptual guide to designing the harness around an LLM — the agent loop, single vs multi-agent decisions, when to use sub-agents, context management strategy, and tool selection patterns. Language- and provider-agnostic. Use this skill when designing a new agent system or auditing an existing one.

Tracing, logging, and monitoring LLM agents in development and production — what to log per turn, span design, token cost tracking, multi-turn debugging, and failure mode classification. Use this skill when an agent misbehaves in ways you can't reproduce, or when setting up production telemetry.

Agentic RAG — letting an LLM agent retrieve iteratively via tools (grep, AST query, file read, graph traversal) instead of fixed top-K vector search. Use this skill when one-shot retrieval can't reach multi-hop answers or when code RAG needs structural exploration.

Practical strategies for managing what an LLM sees on each turn — context window budgeting, compaction, summarization, retrieval (RAG basics), conversation memory, and selective context injection. Use this skill when an agent forgets earlier instructions, runs out of context, or returns inconsistent results across long sessions.

Practical prompt engineering for building LLM applications. Covers system prompt structure, instruction design, few-shot, chain-of-thought, role assignment, output formatting, and cross-model differences. Use this skill when crafting the prompt for an agent, debugging "the model is wrong" issues, or migrating prompts between models.

Improving RAG retrieval recall by rewriting queries before search — HyDE, multi-query expansion, decomposition, step-back prompting, and routing. Use this skill when a RAG pipeline retrieves the wrong chunks despite a sensible question, or complex multi-hop questions fail consistently.

Retrieval-Augmented Generation deep dive — chunking strategies, embedding models, vector databases, retrieval quality, reranking, hybrid search, and evaluation. Use this skill when building a RAG pipeline, debugging poor retrieval quality, or choosing between RAG approaches.

RAG for source code — AST/tree-sitter chunking, code embedding models, repo metadata, import/call graphs, cross-repo retrieval. Use this skill when building "talk to my codebase" RAG, indexing Java/TS/Go monorepos, or when generic prose RAG retrieval misses the right code chunks.

How to design tools that LLM agents use well — schema design, naming, descriptions, error semantics, idempotency, return shape, and selection heuristics. Use this skill when adding a new tool to an agent, debugging "the model picks the wrong tool", or auditing an existing tool surface.

GCP fundamentals — projects, IAM, service accounts, Workload Identity, gcloud CLI, Application Default Credentials (ADC), and Secret Manager. Use this skill when bootstrapping a GCP project, granting access to a service, or wiring credentials into a containerised app.

GitHub Actions CI/CD patterns — workflow structure, common triggers, matrix builds, caching, secrets management, reusable workflows, and deployment patterns. Use this skill when setting up or optimizing CI/CD pipelines on GitHub.

Event-driven architecture patterns — message queues, event sourcing, CQRS, saga pattern, and eventual consistency. Use this skill when designing systems that communicate via events or messages, or when decoupling services in a distributed system. Language-agnostic with Go examples.

Building RESTful APIs in Java with Spring Boot — controllers, DTOs, Bean Validation, global error handling with @ControllerAdvice, RFC 7807 ProblemDetail, content negotiation, and pagination. Use this skill when implementing or reviewing REST endpoints in a Spring MVC project.

Microservices architecture patterns — service decomposition, communication (sync/async), service discovery, circuit breaker, API gateway, 12-factor, and when to stay monolithic. Use this skill when designing distributed systems, splitting a monolith, or reviewing a microservices architecture.

Data modeling fundamentals — entity-relationship design, normalization forms, modeling patterns (polymorphism, hierarchy, audit trails), and mapping domain models to database schemas. Use this skill when designing a new data model or refactoring an existing one.

Docker best practices for developers — Dockerfile patterns, multi-stage builds, image optimization, docker-compose for local dev, security hardening, and .dockerignore. Use this skill when containerizing an application, optimizing image size, or setting up a local development environment.

Kubernetes fundamentals for developers — pods, deployments, services, configmaps, secrets, health checks, resource limits, and common debugging. Use this skill when deploying to Kubernetes, writing manifests, or debugging pod issues. Operator-level topics (cluster setup, networking) are out of scope.

RESTful API design principles for backend developers. Use this skill when designing new HTTP APIs, reviewing endpoint structure, choosing status codes, handling errors, or planning versioning and pagination. Language-agnostic but examples lean Go.

Authentication and authorization patterns for web applications — JWT, session, OAuth2/OIDC, social login (Google, LINE), role-based access control (RBAC), password hashing, and token refresh. Use this skill when implementing login, protecting API endpoints, or integrating third-party auth providers.

A systematic approach to debugging — reproduce, isolate, hypothesize, verify. Use this skill when the user is stuck on a bug, has a flaky test, is hunting a race condition, or wants a repeatable process instead of random print statements.

MongoDB with Go — mongo-go-driver usage, document schema design, indexing strategies, aggregation pipeline, transactions, and migration patterns. Use this skill when building Go services backed by MongoDB, designing document schemas, or optimizing query performance.

Observability for Go services — structured logging with slog, OpenTelemetry tracing, metrics with Prometheus, distributed tracing patterns, and correlation IDs. Use this skill when adding observability to a Go service or debugging production issues with inadequate telemetry.

OpenAPI 3 and Swagger UI for Spring Boot via springdoc-openapi — annotating controllers, generating the spec, securing the docs, and choosing between code-first and API-first workflows. Use this skill when documenting a Java REST API or generating client SDKs.