All authors
robsonkades avatar

Claude Skills by robsonkades

github.com/robsonkades
275 skillsA× 2750 installs0 views
Skill EngineeringA

Designing and reviewing agent skills: scope boundaries, the SKILL.md frontmatter contract, progressive disclosure across references and scripts, explicit decision rules, and quality gates. Use when creating a new skill, when reviewing one that is too long or never activates, when deciding what belongs in SKILL.md versus a reference, or when converting an existing prompt into a skill. Does not cover packaging, versioning or distribution, and does not cover writing the domain expertise itself.

developmentperformance
0
2
Slo And AlertingA

Engineering service-level contracts and actionable alerting: defining user-centered SLIs and SLOs with explicit populations and windows, negotiating error-budget policy, separating request- and time-based semantics, deriving multi-window burn alerts, handling low traffic and missing data, and routing symptoms or predictive hazards by urgency and actionability. Use when an SLO is ambiguous, an SLA lacks operating margin, alert noise is high, resource thresholds page without context, or PromQL ...

developmentgojava
0
2
Sql Query PerformanceA

Making one SQL statement fast, from its execution plan rather than a guess: reading estimated against actual rows, finding the operation that actually costs, whether a scan is wrong at all, index selectivity and composite column order, covering indexes, and the predicates that quietly disable an index. Use when a query is slow and the plan has not been read, when "add an index" is the proposed fix, when a predicate wraps the column in a function or compares mismatched types, when OFFSET pagin...

developmentgosql
0
2
Sql Server PerformanceA

Diagnosing and tuning SQL Server 2022+ from engine evidence: waits, blocking/deadlocks, RCSI and version store, cardinality and parameter-sensitive plans, memory grants and parallelism, clustered/columnstore storage, statistics and index maintenance, tempdb/files/memory, readable replicas, and mssql-jdbc behavior. Use when the symptom or proposed change depends on SQL Server internals. Not generic single-query tuning, ORM behavior, or HikariCP sizing.

developmentjavasql
0
2
Startup Cds Crac LeydenA

Cutting JVM startup and warm-up while staying on the JVM: CDS and AppCDS, the Leyden AOT cache (JEP 483/514/515), CRaC checkpoint and restore and its constraints, what each mechanism actually accelerates, verifying the cache is really in use, and measuring time-to-first-good-response instead of time-to-port-open. Use when cold start hurts a serverless or autoscaled deployment, when a CI pipeline pays for hundreds of JVM launches, when a CRaC flag fails with Unrecognized VM option, when an App...

developmentrustgo
0
2
Stateless Service DesignA

Making a service instance disposable so replicas are interchangeable: what stateless actually means — no correctness/routing dependency on one instance's volatile history; the in-process state inventory; and session state as a placement decision between sticky routing, an external store and a signed token. Use when replicas is raised above 1, when a @Scheduled job suddenly runs N times, when a local cache disagrees between instances, when an in-memory rate-limit counter or idempotency map is ...

developmentrustjava
0
2
Stream Processing Runtime PerformanceA

Operating Kafka Streams and Apache Flink for predictable throughput, state and recovery: separating their execution models, sizing partitions or operator parallelism, diagnosing backpressure, bounding native state, and relating commits or checkpoints to result visibility. Use when one partition or operator limits a pipeline, checkpoints grow or stall, RocksDB drives RSS outside the heap, exactly-once changes latency, or effective runtime configuration differs from declared settings. Generic t...

developmentgojava
0
2
Streaming Pipeline TopologiesA

Composable stage shapes for event-driven pipelines — copier, filter, splitter, sharder, merger — with ordering, semantic parallelism, state, shuffle and recovery boundaries; exactly-once scope across source, state and sinks; bounded joins and windows; watermarks, late-data policy, backlog versus flow control, and reproducible replay. Use when a stage is parallelised, when a join grows state without bound, when a stage re-keys the stream, when late events arrive after a window closed, when a w...

developmentjavareact
0
2
Structured ConcurrencyA

StructuredTaskScope as a lifetime guarantee for a fan-out: fork, join, close, and the rule that no subtask thread outlives the block. Covers the API as it stands on each JDK — still a preview API on every released version, renamed between 25 and 26 and changing again in 27 — the Joiner completion policies, scope timeouts, nesting, and what close actually waits for. Use when writing or reviewing a parallel fan-out inside one request, when a sibling task keeps running after another failed, when...

developmenttestingapi
0
2
Structured LoggingA

Designing application logs as governed event schemas: choosing events and fields, correlation and context lifecycle, exception and severity semantics, synchronous versus buffered delivery, overload/drop behavior, injection prevention, data minimization, integrity/retention and measurable cost. Use when logs require regex parsing, correlation is missing or stale across async work, events disappear under load, fields drift between services, failures are duplicated, secrets or untrusted text rea...

developmentrustgo
0
2
Tail Latency AnalysisA

Diagnosing and mitigating end-to-end latency tails: defining the latency population, decomposing stage and queue time with per-request evidence, quantifying fan-out under dependence, attributing correlated JVM/OS/network/dependency events, and selecting bounded tail-tolerance mechanisms such as deadlines, partial results, hedging and load-aware routing. Use when p99/p99.9 regresses, stage percentiles do not explain an end-to-end percentile, deploys create cold tails, wide fan-out amplifies ra...

developmentgojava
0
2
Task Queues And Competing ConsumersA

Distributing work to a pool of interchangeable workers through a queue: the lease and visibility-timeout model, and why an expired lease can duplicate work instead of failing it; sizing the timeout from processing plus prefetch wait; heartbeats and their failure mode; admission and retention bounds; priority starvation; and age, backlog, arrival and drain rate as autoscaling signals. Use when two workers process one message although nothing retried or failed, when a lease is relied on for mut...

developmentrustgo
0
2
Tcp TuningA

The network stack under a JVM service: listen backlog and accept queues, Nagle and delayed ACK, socket buffer sizing against bandwidth-delay product, congestion control choice, keepalive and timeout alignment along the path, and diagnosing retransmissions and queue drops. Use when a small request/response protocol shows a stable ~40 ms latency floor, when a client throws BindException or EADDRNOTAVAIL under burst, when SYNs are dropped at peak, when one core saturates while the others idle on...

developmentgojava
0
2
TddA

Test-driven development as a judgement call rather than a doctrine: the red-green-refactor loop and what each step is actually for, the discipline of watching a test fail for the stated reason, step size, and an explicit account of where TDD pays and where test-after or characterisation is the better choice. Use when deciding whether to drive a change with tests, when starting a bug fix, when a design is hard to test and the cause is not obvious, when tests are being written after the fact to...

developmentgojava
0
2
Technical Debt DecisionsA

Deciding when a shortcut is a legitimate trade and when it is just damage: separating deliberate and inadvertent debt, constraints delivery pressure does not waive, containing a shortcut so it can be undone, recording it where someone will find it, and choosing which debt to repay by its carrying cost rather than by how much it annoys you. Use when a deadline or an incident is pushing work to be cut, when someone proposes shipping now and cleaning up later, when a spike is about to become pro...

developmentgojava
0
2
Thread Sizing And Virtual ThreadsA

Choose and size platform-thread pools or virtual-thread-per-task execution from workload shape, capacity evidence and lifecycle constraints. Covers CPU versus waiting, queue/admission policy, resource limits exposed by virtual-thread migration, ThreadLocal cost, naming, pinning boundaries after JEP 491, and Java 21/24/25 observability. Use when pool size, virtual-thread adoption or post-migration latency/resource pressure is under review.

developmentjavareact
0
2
Timeouts And DeadlinesA

Bounding how long a call may take and propagating that bound: per-hop timeouts versus an absolute deadline, deadline propagation over HTTP and gRPC, remaining-budget arithmetic and refusing work that cannot finish, cooperative cancellation of abandoned callee work, and keeping connect, read, total and retry timeouts consistent. Use when a client sets a connect timeout but no request timeout, when Future.get() or join() is called with no bound, when a timeout is a round number repeated across ...

developmentrustjava
0
2
Unified LoggingA

Constructing, validating and operating HotSpot unified JVM logging: exact versus wildcard tag-set selection, levels, outputs, decorators, file rotation, asynchronous drop/stall modes, runtime VM.log changes, environment-injected options and legacy-flag migration. Use when -Xlog is empty, excessive, missing after restart, rejected at startup, changed live with jcmd, mixed with container logs, or evaluated for overhead. Producing and preserving the intended evidence belongs here; interpretation...

developmentjavasecurity
0
2
Universal Scalability LawA

Fitting and falsifying the Universal Scalability Law (USL): load/resource definition, the scale coefficient gamma, contention alpha, coherency/retrograde beta, peak conditions, identifiability, uncertainty and held-out validation. Use when throughput saturates or falls as threads, users, cores or pods increase; when scale-out is proposed from too few points; or when comparing architectural scalability curves. Does not cover `L = λW`, queue/pool sizing (littles-law-and-queueing), latency-at-lo...

developmentpythonjava
0
2
Varhandles And Memory OrderingA

Designing and proving low-level Java variable access with VarHandle plain, opaque, acquire/release and volatile modes; compare-and-set/exchange, weak CAS, read-modify-write, fences, coordinates, signature-polymorphic typing, supported modes, and mixed-access hazards. Connects modes to synchronization edges and allowed outcomes, with model, generated-code and performance evidence when relevant. Use when selecting or reviewing low-level access modes, adapting existing handles or dynamic coordin...

developmentgojava
0
2
View And Representation PatternsA

Producing the response: Template View, Transform View and Two Step View as three ways to turn a model into output, and what each becomes in a JSON API, a server-rendered page or a hypermedia fragment. Use when logic is accumulating inside templates, when a template triggers database queries during rendering, when the same data must be rendered in several formats and the mapping is duplicated per format, when a consistent look or envelope must be applied across every screen or endpoint, when e...

developmentrustgo
0
2
Virtual Thread MigrationA

Migrating an existing service to virtual threads as a staged programme rather than a flag: inventorying what each thread pool was implicitly limiting, auditing for pinning, file I/O and ThreadLocal caches, declaring the replacement limits before the flip, canarying one workload at a time, re-sizing the connection pool, and the rollback criteria. Use when a team plans to enable virtual threads service-wide, when a single flag is about to be flipped in production, when a migration made latency ...

developmentgojava
0
2
Virtual Threads InternalsA

Diagnose HotSpot virtual-thread mounting, heap stack chunks, FIFO work-stealing scheduling, carrier capture, residual native/VM-frame pinning after JEP 491, scheduler compensation boundaries and memory/GC effects without treating implementation details as API guarantees. Use when pin events, scheduler queue/pool growth, native calls or class initialization, CPU-ready virtual threads or retained suspended stacks explain a scalability regression on Java 21–25. Not introductory adoption (thread-...

developmentjavaapi
0
2
Zgc And ShenandoahA

Operating ZGC and Shenandoah in production: concurrent relocation via coloured pointers and load barriers, the CPU the concurrent phases actually take, allocation stalls, and which flags still exist. Use when a service migrated to a concurrent collector and throughput dropped, when a GC log shows "Allocation Stall", when a pod of 1-2 CPUs runs ZGC or Shenandoah, when a config still carries -XX:+ZGenerational or G1 flags after the migration, when a ZGC-versus-Shenandoah comparison does not dec...

developmentgojava
0
2
Zgc Generational InternalsA

Generational ZGC internals: coloured pointers without multi-mapping, the load and store barriers, the young and old cycles and their STW phases, the remembered-set bitmap and its double buffering, relocation and page management, allocation stalls, and the generational log and JFR event names. Use when a deploy script still carries -XX:+ZGenerational, when jdk.ZAllocationStall events appear or allocation stalls cluster in traffic peaks, when a pause script greps only "Pause Mark" and reports a...

developmentgogit
0
2