Claude Skills by gethamster

Ask every independent decision an agent needs in one call against one state snapshot, then measure the cost and latency you save.

Measure a full agent loop end to end, run new decision layers in shadow mode, and log versioned decisions so every change can be attributed.

Set up a kernel and AI service, give the agent a persona, and run a chat loop with automatic function calling enabled.

Earn trust by modeling the standards you expect, putting the group's needs first, and acting consistently with shared values.

Build and maintain an opportunity solution tree that links one measurable outcome to customer opportunities, candidate solutions, and assumption tests.

Construct, test and revise the mental models that turn raw observations into an updated situational picture and a set of response options.

Wire a retriever, vector store, reranker and model into a LangChain pipeline that answers from your documents, and prove it with evaluation.

Turn ideas into rough, cheap artifacts users can see, handle, or act out, then learn from how they use them before investing more.

Turn a research-backed concept into cheap, fast prototypes that real users can react to, so the team learns before it commits.

Define the subject area your site will own and lay it out as categories, subcategories and the concepts each must cover.

Turn a decision model's confidence scores into measured thresholds that decide when an agent acts, falls back, or escalates.

Line up a decision model's stated confidence with the success rates you actually observe, per task type, using logged predictions and outcomes.

Compose prompt templates, models and output parsers into explicit, testable multi-step LLM chains, and know when a chain should become a graph.

Confirm an agent action changed the world as intended by comparing a pre-written expected outcome with fresh evidence gathered after it ran.

Choose a single session, subagents, or an agent team by weighing context, peer messaging, file overlap, token cost and experimental limits.

Sort raw long-tail queries by the job the searcher is trying to do, then roll those use-case clusters into silos a set of pages can own.

Evaluate several candidate solutions side by side so your product trio surfaces trade-offs and avoids committing to the first idea.

Compare transformational, servant and authentic leadership by focus, beneficiary and risk, then choose or blend a model for a specific team.

Plan and run in-context interviews and observation so a design team sees what people actually do, not only what they say.

Test designs with real users and expert reviewers so that evidence, not opinion, drives and refines each design decision.

Set up and run story-based customer interviews every week so your product trio always has fresh evidence for discovery decisions.

Keep provider and model choices in config, then pass a BaseChatModel instance or identifier string into LangChain components so models swap cleanly.

Keep independent Claude Code teammates aligned through targeted, self-contained mailbox messages, direct interventions and careful recovery after resume.

Align several Agile Release Trains on one large solution through shared cadence, solution-level roles and explicit cross-ART dependency management.

Write a concrete, problem-grounded vision, connect each person's role to it, and use it in everyday decisions to build inspirational motivation.

Write parameterized LangChain prompt templates with named variables, fixed instructions and strict output formats that you can reuse and test.

Build a reusable template that plans every topic you intend to own, tracks coverage by funnel stage, and sets a review rhythm for updates.

Turn a high-level objective into self-contained, checkable tasks with clear boundaries and dependencies before an Agent Team starts parallel work.

Replace feature roadmaps with measurable behavior-change goals that give product teams room to discover solutions and stay accountable to results.

Turn research insights into unmet needs, a reframed problem, How might we questions, design principles and testable requirements.

Write observable, thresholded acceptance criteria before an agent loop starts, so every verify step has a clear pass or fail.

Wrap keyword research, content optimization and SEO audits as agent tools, then let an agent chain them into ranked recommendations.

Define distinct Agent Team roles with one focus, owned files and explicit exclusions so parallel teammates never edit the same code.

Build a LangChain agent by pairing a model with a harness of prompt, tools and middleware, then add control and delegation only where needed.

Structure a site so each page answers one audience question up front, carries matching FAQ markup and links back to a single entity home.

Place human review and approval points in AI agent workflows so tool actions stay scoped, auditable and escalated to a person when needed.

Plan what context carries between turns and sessions so long Claude Code work stays accurate instead of rotting.

Build rewards that score a model's stated probabilities against realized outcomes so training pushes confidence toward observed correctness.

Use typed decision calls to choose workers, tools, models and next steps, and to score sources, while code enforces the result.

Define a bounded answer space and typed schema so a model returns decisions and probabilities software can validate and act on.

Set up shared version control, unattended automated tests, frequent integration and protected focus time for developers.

Catch confirmation bias, anchoring and groupthink while orienting, and turn a favored hunch into a tested working interpretation.

Tell exchange-based transactional leadership apart from transformational leadership and combine both without losing clarity.

Model a rival's observe-orient-decide-act cycle, then act with tempo and irregularity so their picture of the situation keeps going out of date.

Make code the only path to side effects: gate permissions, validate arguments, run tools, and verify and log real outcomes.

Control what tool results, command output and subagent findings flow back into a Claude agent's context so each loop stays focused.

Create conditions where team members can raise problems, admit mistakes and disagree openly, the first step toward trust in Crystal.

Attach a probability to every structured decision and check it against real outcomes, so software knows when to act and when to escalate.

Check whether a model's stated probabilities match real outcome rates with probability bins, reliability plots and expected calibration error.

Produce templated long-tail pages at scale that each add unique value, get indexed, and connect into a clear user journey.