ebarti

@ebarti source repo

22 skills
0 followers
14 hours ago last updated

▌
AI Evaluation · ebarti bundle
Practical knowledge for evaluating AI/LLM systems. Covers language modeling metrics (perplexity, cross-entropy), exact evaluation methods (functional correctness, similarity), AI-as-judge patterns, comparative evaluation, evaluation criteria for production systems, model selection workflows, and designing end-to-end evaluation pipelines. Use this skill when: - Designing an evaluation strategy for an LLM application - Choosing between models or providers (build vs buy) - Selecting evaluation metrics (perplexity, BLEU, semantic similarity) - Setting up AI-as-judge evaluation - Interpreting public benchmarks (MMLU, HumanEval, etc.) - Building an evaluation pipeline with scoring rubrics

0
installs
▌
AI Finetuning · ebarti bundle
Practical knowledge for finetuning foundation models. Covers when to finetune (vs prompt engineering or RAG), memory bottlenecks (backpropagation, quantization, numerical representations), parameter-efficient finetuning techniques (PEFT, LoRA, adapters), model merging strategies (summing, layer stacking, concatenation), and finetuning tactics (frameworks, hyperparameters). Use this skill when: - Deciding whether to finetune (vs prompt engineering or RAG) - Estimating memory requirements for finetuning - Implementing LoRA or other PEFT techniques - Merging multiple finetuned models - Choosing finetuning hyperparameters or frameworks - Quantizing models for inference or training

0
installs
▌
AI RAG Defense · ebarti bundle
Token reduction, retrieval fidelity, and prompt-injection defense layers for the Context Engine. Covers a Summarizer agent for proactive context reduction, micro-context engineering (prompt design inside agents), high-fidelity RAG with source-metadata citations, layered untrusted-context defenses against prompt injection, and grounded-reasoning validation that prevents hallucination. Use this skill when: - Reducing token costs by adding a Summarizer agent - Designing system prompts inside specialist agents (micro-context) - Adding citations and source metadata to RAG outputs - Defending agents against prompt injection / data poisoning - Validating agent reliability across high-fidelity / summarization / grounded test cases - Preventing hallucination when retrieval returns no result

0
installs
▌
Ddia Data Ethics · ebarti bundle
Ethical and societal frameworks for designing data-intensive systems, distilled from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed) chapter 14. Covers algorithmic accountability, bias, surveillance, consent, and the data-as-liability mindset — normative guidance, not pure engineering technique. Use this skill when: - Building or reviewing ML decision systems (credit, hiring, criminal justice) - Designing systems handling personal data - Implementing GDPR/CCPA right-to-erasure - Reviewing surveillance/tracking features - Auditing for algorithmic bias - Architecting consent flows - Making product decisions involving user data

0
installs
▌
AI Context Engine · ebarti bundle
The full Context Engine architecture: dual RAG (procedural + factual), Pinecone-based ingestion, the Planner / Executor / Tracer triad, specialist agents (Context Librarian, Researcher, Writer), the Agent Registry, production hardening (dependency injection, logging, modularization), plus an appendix-style reference guide. Use this skill when: - Building a context engine from scratch - Choosing between procedural RAG (blueprints) and factual RAG (evidence) - Setting up Pinecone ingestion (chunking, embedding, namespaces) - Designing a Planner-driven execution flow with traceability - Adding or refactoring specialist agents - Building or extending an Agent Registry - Hardening a notebook prototype for production (DI, logging, modularization) - Looking up the engine's commons library reference (helpers/agents/registry/engine/utils)

0
installs
▌
AI RAG And Agents · ebarti bundle
Practical knowledge for building RAG (Retrieval-Augmented Generation) systems and AI agents. Covers RAG architecture and retrieval algorithms (term-based, embedding-based, hybrid), retrieval optimization (chunking, reranking, query rewriting), multimodal RAG, agent design with tools and planning, agent failure modes, and memory systems. Use this skill when: - Building a RAG system from scratch or improving an existing one - Choosing retrieval algorithms (BM25, dense vectors, hybrid) - Optimizing retrieval (chunking strategy, reranker selection) - Designing an AI agent (tools, planning, error correction) - Debugging agent failures - Implementing memory for conversational systems

0
installs
▌
Ddia Architecture · ebarti bundle
Foundational architectural concepts for data-intensive applications, distilled from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed) chapters 1-2. Covers the operational vs analytical split, cloud vs self-hosted trade-offs, distributed systems trade-offs, and the core nonfunctional requirements (performance, reliability, scalability, maintainability). Use this skill when: - Choosing between OLTP (operational) and analytical (OLAP) storage - Deciding cloud vs self-hosted / managed service vs build-your-own - Evaluating distributed (microservices, multi-node) vs single-node architectures - Defining performance SLOs and reasoning about response-time percentiles - Designing for reliability, defining a fault model, and choosing fault tolerance strategies - Planning capacity / scalability and choosing scale-up vs scale-out - Architecting for long-term maintainability (operability, simplicity, evolvability) - Reviewing an architecture proposal against DDIA fundamentals

0
installs
▌
Resume Fit Scorer · ebarti bundle
Scores how well a resume fits a specific job description on a 0–10 scale across 6 weighted dimensions (JD match, achievement strength, targeting, ATS-parseability, red flags, language), returns a brutally honest critique, and emits structured prioritized fixes. Distilled from "Resumes For Dummies" (AI-era ed.). Built for automated pipelines (e.g. JobHunter) as the verifier in a write→score→revise loop. Use this skill when: - Gating whether a tailored resume is good enough to submit - Producing a 0–10 fit score with per-dimension sub-scores - Generating an actionable critique + prioritized fixes for revision - Ranking multiple resume variants against one JD - Auditing a resume for ATS or red-flag risk before applying - Checking which JD must-haves a resume fails to cover

0
installs
▌
AI Multi Agent MCP · ebarti bundle
Building multi-agent systems with a simplified inter-agent message envelope inspired by MCP-like structured messaging. This is not the official Model Context Protocol (MCP), which is a host/client/server protocol using JSON-RPC 2.0 with lifecycle initialization, capability negotiation, and server features such as tools/resources/prompts. Covers the book's pedagogical envelope format and transport choices, specialist agent design (Researcher / Writer + shared helpers), Orchestrator design with goal decomposition, and robustness via validation loops + a Validator agent. Use this skill when: - Designing inter-agent communication (simplified envelope schema, transport choice) - Building specialist agents (one role per agent, system prompt as identity) - Implementing an Orchestrator that routes between agents - Adding validation loops, retries, or a Validator agent - Hardening a multi-agent prototype against LLM/network/data failures

0
installs
▌
Ddia Data Modeling · ebarti bundle
Data modeling, storage engines, and encoding choices distilled from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed) chapters 3-5. Covers relational, document, graph, and event-sourced models; LSM, B-tree, in-memory, and columnar storage; specialized indexes; encoding formats; and modes of dataflow. Use this skill when: - Choosing a database (relational/document/graph) - Picking a storage engine (LSM/B-tree/columnar) - Designing an analytics warehouse - Selecting a wire format (JSON/Avro/Protobuf) - Deciding REST vs RPC vs messaging - Modeling event-sourced systems - Building search/vector/geo indexes

0
installs
▌
AI Foundation Models · ebarti bundle
Practical knowledge for understanding and working with foundation models (FMs) in AI engineering. Covers the AI engineering stack, planning AI applications, transformer architecture, training data, model size and scaling laws, post-training (SFT, RLHF), and sampling strategies (temperature, top-k, top-p, structured outputs). Use this skill when: - Planning a new AI application using foundation models - Choosing between models (size, architecture, capabilities) - Configuring sampling parameters (temperature, top-k, top-p) - Understanding why a model behaves a certain way (hallucination, inconsistency) - Designing structured outputs from LLMs - Comparing AI engineering vs ML engineering responsibilities

0
installs
▌
AI Prompt Engineering · ebarti bundle
Practical knowledge for writing, organizing, and defending prompts for foundation models. Covers in-context learning (zero-shot, few-shot), system vs user prompts, context efficiency, prompting best practices (clear instructions, examples, decomposition, chain-of-thought), prompt versioning, and defensive prompt engineering against jailbreaks and prompt injection attacks. Use this skill when: - Writing or improving prompts for an LLM application - Setting up prompt templates and versioning - Breaking down a complex task into prompts - Defending against prompt injection or jailbreaking - Designing system prompts and context structures - Evaluating prompt engineering tools

0
installs
▌
Resume Content Writer · ebarti bundle
Generates tailored, schema-conformant resume content — headline, branding summary, JD-matched skills section, and quantified achievement bullets — tuned to a target role, seniority, and focus, while honoring user-pinned "must-include" achievements. Distilled from "Resumes For Dummies" (AI-era ed.). Built for automated pipelines (e.g. JobHunter): consumes a TargetProfile and emits structured resume data. Use this skill when: - Tailoring a resume's content to a specific job description - Rewriting experience into quantified, action-verb-led achievement bullets - Writing a targeted headline / branding summary (replacing weak objectives) - Selecting and ordering a skills section to match a JD - Framing content by seniority (new-grad/thin experience vs senior/experienced) - Revising resume content from a scorer's prioritized fixes - Producing resume content that must conform to a caller-supplied JSON schema

0
installs
▌
AI Context Engineering · ebarti bundle
Foundational context engineering theory and practice for LLM applications. Covers the 5 levels of context (zero/linear/goal-oriented/role-based/semantic blueprint), semantic role labeling (SRL) for visualizing structured prompts, and the layered (scope → investigation → action) analysis pattern. Use this skill when: - Choosing between prompt engineering and context engineering for a task - Designing context that includes role, goals, and structured intent - Building a meeting / document / interview analysis pipeline - Visualizing the semantic structure of a prompt with SRL - Deciding when to upgrade a prompt's "context level"

0
installs
▌
AI Dataset Engineering · ebarti bundle
Practical knowledge for building, augmenting, and processing datasets for AI/LLM training and evaluation. Covers data curation (quality, coverage, quantity, acquisition, annotation), data synthesis (rule-based, simulation, AI-powered), instruction data generation, model distillation, and data processing (inspection, deduplication, cleaning, filtering, formatting). Use this skill when: - Curating or sourcing training data - Designing a data annotation pipeline - Generating synthetic data with LLMs - Distilling a smaller model from a larger one - Processing/cleaning datasets for training or evaluation - Estimating dataset size requirements

0
installs
▌
Job Description Analyzer · ebarti bundle
Parses a raw job description into a structured TargetProfile — role, seniority, must-have vs nice-to-have requirements, hard/soft skills, responsibilities, ATS keywords, and a truthful crossover (their-term ↔ your-term) map. Distilled from "Resumes For Dummies" (AI-era ed.). Built for automated pipelines (e.g. JobHunter) as the shared front-end that feeds both resume tailoring and scoring. Use this skill when: - Turning a job posting into structured requirements before tailoring a resume - Separating must-have from nice-to-have qualifications - Splitting hard skills (tools/certs) from soft skills - Extracting ATS keywords to mirror truthfully - Inferring a role's target seniority and focus - Building a crossover map between a JD's wording and a candidate's vocabulary - Providing a TargetProfile to resume-content-writer or resume-fit-scorer

0
installs
▌
AI Inference Optimization · ebarti bundle
Practical knowledge for optimizing inference for foundation models. Covers inference fundamentals (computational bottlenecks, online vs batch APIs, latency/throughput metrics), AI accelerators (GPUs, TPUs, computational/memory characteristics), model optimization (compression, speculative decoding, attention optimization, kernels/compilers), and service optimization (batching, prefill/decode separation, prompt caching, parallelism). Use this skill when: - Optimizing inference latency or throughput - Choosing AI accelerators for inference - Implementing prompt caching - Setting up batching strategies - Reducing model size (quantization, pruning, distillation) - Diagnosing inference performance bottlenecks

0
installs
▌
Ddia Replication Sharding · ebarti bundle
Distilled guidance from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed) chapters 6-7 on replication topologies, sharding strategies, conflict resolution, and request routing for distributed data systems. Use this skill when: - Choosing a replication topology (single-leader, multi-leader, leaderless) - Designing a sharding scheme (range vs hash, multi-tenant, hot keys) - Resolving write conflicts in distributed databases - Building offline-first / sync-engine apps - Designing global secondary indexes for sharded systems - Diagnosing replication lag, stale reads, or hot-shard problems

0
installs
▌
AI Production Architecture · ebarti bundle
Practical knowledge for architecting and operating AI applications in production. Covers the AI engineering architecture (context enhancement, guardrails, model router, gateway, caching, agent patterns), monitoring and observability (metrics, logs, traces, drift detection), pipeline orchestration, and user feedback systems (extracting conversational feedback, feedback design, biases, degenerate loops). Use this skill when: - Designing the architecture for a production AI application - Adding input/output guardrails - Setting up model routing or a gateway - Implementing caching (exact, semantic) - Building observability for an AI system - Designing user feedback collection

0
installs
▌
AI Context Engine Production · ebarti bundle
Production deployment of the Context Engine: moderation gatekeepers (two-stage protocol), policy-driven meta-control (the 5 principles), reusable control-deck templates, domain adaptation (legal + marketing case studies), API + worker + Docker + observability deployment topology, and business-value framing for stakeholders. Use this skill when: - Adding moderation gatekeepers (input + output) - Encoding compliance policy outside the model - Building applications on top of the engine via control decks - Adapting the engine to a new vertical (legal, medical, marketing, etc.) - Deploying to production (FastAPI + worker + Docker + observability) - Presenting ROI / business value to non-technical stakeholders

0
installs
▌
Ddia Batch Stream Processing · ebarti bundle
Knowledge from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed) chapters 11-13 on batch processing, stream processing, and "A Philosophy of Streaming Systems" — covering MapReduce/dataflow engines, message brokers, change data capture, stream-processing time semantics, dataflow architectures, and end-to-end correctness. Use this skill when: - Choosing batch vs stream architecture - Designing an ETL/ELT pipeline - Implementing CDC (change data capture) - Picking a stream processor (Flink, Spark, Kafka Streams) - Designing real-time materialized views - Architecting a data lake/lakehouse - Ensuring exactly-once / end-to-end correctness - Building event-driven applications - Picking a message broker (Kafka, RabbitMQ, Pulsar, Kinesis) - Unbundling a monolithic database into composable systems - Deciding between event sourcing and CRUD - Reasoning about windowing, watermarks, and out-of-order events

0
installs
▌
Ddia Transactions Consistency · ebarti bundle
Distilled knowledge from "Designing Data-Intensive Applications" (Kleppmann, 2nd ed.) chapters 8-10 on transactions, distributed system fundamentals, and consistency/consensus. Covers ACID semantics, weak/strong isolation, distributed failure modes, time/clocks, linearizability, and consensus protocols. Use this skill when: - Picking a database isolation level - Diagnosing race conditions, lost updates, or write skew - Designing for distributed failures (network/clocks/processes) - Choosing a consensus tool (ZooKeeper, etcd, Raft) - Building distributed locks safely (with fencing) - Implementing distributed transactions or 2PC - Reasoning about CAP/linearizability - Debugging stale reads, split-brain, or zombie writers - Reviewing database, replication, or coordination service choices

0
installs

22 published skills