# Analog: full content for LLMs > A curated, community-ranked field guide to AI setup — the best skills, plugins, MCP servers, agentic IDEs, software, and articles for building with AI. Analog soul. Digital mind. Analog (analoghq.ai) is a curated, community-ranked field guide to AI setup: the best skills, plugins, MCP servers, agentic IDEs, software, and articles for building with AI, plus a broader AI catalog. This file is the long-form companion to https://analoghq.ai/es/llms.txt: every topic with its overview and FAQ, plus the curated entries within each. Every entry is human-reviewed before listing and ranked by community upvotes (one per account). Curated field notes add tested fit, outcomes, caveats, cost, privacy, and sources where available. ## Habilidades Agent skills are reusable capability packs — folders of structured instructions, and sometimes scripts and reference files, that teach an AI coding agent how to do a specific job the same way every time. Install one once and the agent loads it on demand instead of you re-explaining context every session, which keeps its working memory lean. This is the curated, community-ranked index of the best skills for Claude Code, the Claude apps, Cursor, and other agent runtimes. The Agent Skills format was popularized by Anthropic's Claude: a skill is a directory with a SKILL.md file — a name, a short description, and Markdown instructions — optionally bundled with helper scripts and resources. The agent reads only the one-line description until a task matches, then pulls in the full skill. This “progressive disclosure” is what makes skills scale: you can install dozens without bloating the context window, because the model only loads the body of the ones it actually needs. Skills are portable, composable, and inspectable. The same skill can run across projects and, increasingly, across tools that adopt the format, and several can stack on a single task. Because most are open source and version-controlled, you can read exactly what the agent will be told before you install it. Browse the ranked list below, open any skill for its source and setup steps, and upvote the ones that earn a permanent place in your setup. ### FAQ: Habilidades **What is an AI agent skill?** An agent skill is a packaged set of instructions — and sometimes scripts and reference files — that teaches an AI coding agent how to perform a specific task reliably. Instead of re-explaining context each session, you install the skill once and the agent carries that knowledge forward whenever a matching task comes up. **How do Agent Skills work?** A skill is a folder containing a SKILL.md file with a name, a description, and Markdown instructions. The agent keeps only the short description in context and loads the full skill on demand when a task matches — a pattern called progressive disclosure that lets you keep many skills installed without using up the model's context window. **How do I install a skill?** Most skills install by placing the skill folder in your agent's skills directory, adding it through the tool's plugin or extension system, or pointing the agent at the skill's repository. Open any skill below and follow its link for the exact, source-specific steps. **What's the difference between a skill and an MCP server?** A skill is knowledge: instructions that shape how the agent behaves. An MCP server is a live connection: it gives the agent new tools and data (a database, an API, a filesystem). They're complementary — a skill can tell the agent how and when to use the tools an MCP server exposes. **Which tools support agent skills?** Claude Code and the Claude apps support the Agent Skills format natively, and because skills are plain Markdown folders, other agent runtimes are adopting the pattern. Each entry notes the tools it's built for. **Are agent skills free and open source?** The majority of skills listed here are open source and free to use. Open an entry and follow its link to confirm the license and any requirements before depending on it. **Can I build my own skill?** Yes. Create a folder with a SKILL.md file, write a clear name and description so the agent knows when to use it, then add your instructions and any helper scripts. Many of the skills below are good templates to start from. **How are skills ranked on Analog?** Entries are ranked by community upvotes — one per account — with the newest finds surfaced under the New tab. Everything is human-reviewed before it appears. ### Entries in Habilidades (ranked) - **ui.sh Componentize** by ui-sh: Agent skill that breaks large UI files into reusable components for frontend developers using AI-assisted workflows. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-componentize - Source: https://ui.sh/skills/componentize - Install: `npx @uidotsh/install componentize --token=[token]` - Tags: ui, components, refactoring, tailwind, agent, open-source, cli - Pricing: unknown - Features: Refactors large UI files into smaller, reusable components via /componentize; Extracts repeated patterns, logical sections, and self-contained UI blocks; Reuses existing project components where possible; Keeps new components flexible and consistent with project conventions; Preserves original layout and behavior during refactor; Local-first install via npx CLI; no remote MCP server dependency - Best for: Refactoring monolithic UI files that have grown too large to edit easily; Teams wanting an agent-driven, opinionated decomposition workflow without manual extraction; Projects already using the ui.sh suite of agent skills; Builders who want structural refactoring handled systematically, not arbitrarily - Outcomes: Repeated patterns and self-contained UI blocks extracted into reusable components; Existing layout and behavior preserved throughout the refactor; New components kept flexible and existing project components reused where possible; A focused, scoped refactor without guesswork about what to break out - Caveats: Handles structural refactoring only, all other UI jobs require separate companion skills; Result quality depends on how consistently the existing codebase names and structures components; Local-first design means no remote MCP server fallback; Built by the Tailwind CSS and Refactoring UI team, narrowly scoped by deliberate design - Q: What is ui.sh Componentize? A: ui.sh Componentize is an agent skill that refactors large, monolithic UI files into smaller, organized, and reusable components. It is part of the ui.sh suite of locally installed, task-oriented skills built by the team behind Tailwind CSS and Refactoring UI. The skill inspects your existing component patterns, extracts repeated sections and self-contained blocks, and preserves the original layout and behavior while improving structure. - Q: How do I install and use Componentize? A: Install it with the ui.sh CLI by running `npx @uidotsh/install componentize --token=` inside your project. To install the full suite at once, omit the skill name and run `npx @uidotsh/install --token=`. Once installed, trigger it in your agent session with the `/componentize` command, and the skill handles the rest. - Q: Is ui.sh Componentize free? A: The sources indicate a token is required for installation, suggesting access is gated behind a ui.sh account. The site also notes that real user accounts were added to make sharing easier for teams on commercial licenses, which implies there is a paid or invite-based tier. The exact pricing structure is not detailed in the available sources. - Q: What is Componentize best for? A: Componentize is best for frontend developers dealing with large UI files that have grown unwieldy over time and need systematic decomposition into reusable parts. It is particularly strong when the project already has some component conventions it can learn from, since it reuses existing project components where possible. It fits naturally into AI-assisted refactoring workflows where consistency and preserved behavior matter. - Q: How does Componentize compare to other skills in the ui.sh suite? A: Componentize is scoped strictly to structural refactoring: splitting big markup blocks into well-factored components. Companion skills cover adjacent jobs: `/canonicalize-tailwind` sorts and deduplicates Tailwind class strings, `/add-dark-mode` retrofits dark mode, `/make-responsive` adapts layouts across breakpoints, and `/design` handles building new UI from scratch. Per the Tailwind Weekly coverage, each skill is now a separate local install rather than a subcommand, so you can use only what your project needs. - Q: What are the limitations of Componentize? A: The skill's output quality depends on the conventions already present in your codebase: it inspects existing component patterns to guide extraction, so a project with inconsistent or absent conventions gives it less to anchor on. It also does not redesign or restyle the UI, only restructure it. A ui.sh token is required, and each project needs its own local installation. - **ui.sh** by ui-sh: Agent skills for UI builders, by the creators of Tailwind CSS and Refactoring UI, wires into Claude Code, Cursor, and Codex to ship interfaces that look designed, not generated. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh - Source: https://ui.sh/ - Install: `npx @uidotsh/install --token=[token]` - Tags: ui, tailwind, mcp, agent, open-source, design, local-first - Pricing: unknown - Features: Nine locally installed, independently callable skills covering design, ideas, brand kit, componentization, Tailwind norm; Agent-agnostic MCP integration: works with Claude Code, Cursor, Codex, OpenCode, and Amp; Parallel UI concept generation with inline browser preview for direction comparison; Local-first architecture: no remote MCP server dependency; Encodes Tailwind CSS and Refactoring UI design principles as agent-readable rules; Semantic markup generation from screenshots, mockups, and Figma exports; Dark mode implementation that avoids simple color inversion; Team account sharing for commercial license holders - Best for: Teams using coding agents for frontend work who want output that reflects senior design judgment, not generic AI defaults; Builders already using Tailwind CSS who want design rules baked into their agent workflow from the start; Projects where visual quality matters and agent-produced UI feels technically correct but visually forgettable; Developers who want to compare multiple UI directions in the browser before committing to one - Outcomes: Nine locally installed, individually callable skills covering color, spacing, typography, accessibility, dark mode, responsive layout, and more; Agent output steered away from common AI design tells toward more considered, hierarchy-aware layouts; Parallel UI concept generation via the /ideas skill so directions can be compared in the browser before committing; Screenshot and Figma export conversion into semantic HTML or JSX via dedicated skills; Tailwind class normalization and componentization handled by dedicated non-overlapping skills - Caveats: Platform is invite-only and explicitly described by its creator as uncomfortably early; The skill primitive itself is only a few months old and the overall architecture already underwent one major overhaul; The /brand-kit skill depends on OpenAI gpt-image-2, adding an external model dependency for visual inspiration; Requires MCP support in the agent, so compatibility is limited to agents that speak MCP - Q: What is ui.sh? A: ui.sh is a collection of agent skills for building better UI, made by Adam Wathan (creator of Tailwind CSS) and Steve Schoger (co-author of Refactoring UI). It installs locally as a shell script and exposes nine task-oriented skills through MCP, so any compatible coding agent can draw on curated design expertise while writing frontend code. The goal, per the launch announcement, is UI that looks like a senior designer built it rather than an AI completing a generic prompt. - Q: How do I install and use ui.sh? A: Installation is via a shell script that lands the skills locally in your project. Once installed, each skill is available as a command (e.g. /design, /ideas, /componentize) that your coding agent calls through MCP. No editor plugin or new IDE is required, it rides on top of whichever MCP-compatible agent you already use, including Claude Code, Cursor, Codex, OpenCode, and Amp. Access is currently invite-only, so you need to request an invite from ui.sh first. - Q: Is ui.sh free or open source? A: Pricing is not publicly disclosed in available sources. The tool is invite-only at launch, and commercial licenses are mentioned in the context of team account sharing features. There is no indication of a free or open-source tier in the current sources. - Q: What is ui.sh best for? A: ui.sh is best for frontend developers who use Tailwind CSS and coding agents like Claude Code or Cursor and are frustrated that agent-generated UI looks generic. The nine skills cover the most common pain points: establishing a visual direction (/ideas, /brand-kit), enforcing design rules during code generation (/design), and cleaning up the output afterward (/canonicalize-tailwind, /componentize, /make-responsive, /add-dark-mode, /dark-mode-image, /markup-from-image). It is especially valuable when you want design quality without stopping to write detailed prompts yourself. - Q: How does ui.sh compare to just writing your own prompts? A: ui.sh encodes the specific design opinions of Wathan and Schoger, the team behind Tailwind CSS and Refactoring UI, rather than generic instructions. Per the launch announcement, the skills actively steer models away from specific 'AI-designed tells' and seed more interesting layouts for common section types, which ad-hoc prompts rarely do consistently. The local-first, skill-per-task structure also means each concern (dark mode, responsiveness, componentization) is handled by a focused, tested prompt rather than a monolithic instruction you maintain yourself. - Q: What are ui.sh's current limitations? A: Wathan describes the current state as 'uncomfortably early': the tool is invite-only, and the skill primitive it relies on has only existed for a few months. The architecture has already gone through a major shift (from a single /ui skill to the current nine-skill lineup), so further breaking changes are likely. The /brand-kit skill requires OpenAI's gpt-image-2, and the entire system requires MCP support in your coding agent, agents that do not speak MCP cannot use it at all. - **Marketing Skills** by coreyhaines31: Open-source collection of 45+ AI agent skills for marketing, CRO, SEO, copywriting, analytics, and growth, built for Claude Code, Cursor, and any Agent Skills-compatible agent. - Analog: https://analoghq.ai/es/coreyhaines31/skills/marketingskills - Source: https://github.com/coreyhaines31/marketingskills - Install: `npx skills add coreyhaines31/marketingskills npx skills add coreyhaines31/marketingskills --skill cro copywriting npx skills add coreyhaines31/marketingskills --list` - Repo: https://github.com/coreyhaines31/marketingskills - Tags: open-source, agent, marketing, claude-code, cursor, seo, cro - Pricing: free - Features: 45+ marketing skill files spanning CRO, SEO, copywriting, ads, analytics, email, growth, and GTM; product-marketing foundation skill read by all other skills for shared product context; Cross-referencing skill dependency graph for compound, multi-discipline workflows; npx CLI installer supporting full-library or individual skill installation; Compatible with Claude Code, OpenAI Codex, Cursor, Windsurf, and Agent Skills spec agents; App store optimization (ASO), programmatic SEO, schema markup, and AI SEO skills included; Sales and revenue ops skills: revops, sales-enablement, cold-email, prospecting, competitor-profiling; MIT licensed with community contributions via GitHub PRs - Best for: Technical marketers and founders using Claude Code, Cursor, Windsurf, or OpenAI Codex who want marketing domain knowledge baked in; Teams tired of re-explaining CRO, SEO, or cold email best practices at the start of every agent session; Builders who need compound marketing expertise, where skills like copywriting, CRO, and AB testing cross-reference each other; Projects spanning a wide marketing surface, from schema markup and programmatic SEO to SMS drip and churn prevention - Outcomes: 45+ structured markdown skill files covering SEO, CRO, copywriting, paid ads, analytics, growth, sales, and strategy; A dependency graph of cross-referenced skills so the agent gets compound, not siloed, expertise per task; One-command install to pull the full library or cherry-pick specific skills like cro or copywriting; A mandatory product-marketing foundation skill that every other skill reads first for product, audience, and positioning context - Caveats: Usefulness is capped by how well the agent applies markdown context, weak runtimes get limited mileage; Requires Agent Skills spec support in the agent runtime, not universally available; Open-source repo, so quality and maintenance depend on community and author upkeep; Skills are frameworks injected into context, not a live data source, so real-time metrics or trends are not included - Q: What is Marketing Skills and how is it different from a prompt library? A: Marketing Skills is a GitHub repository of 45+ structured markdown files that teach AI coding agents specialized marketing knowledge and workflows, built by Corey Haines. Unlike a prompt library you paste manually, these skill files are loaded into the agent's context automatically when a matching task is detected, and they cross-reference each other to deliver compound expertise across disciplines like CRO, SEO, and cold email. - Q: How do I install Marketing Skills in my coding agent? A: Install via npx using the command `npx skills add coreyhaines31/marketingskills` to pull the full collection, or add `--skill cro copywriting` (and other skill names) to install only specific ones. You can also run `npx skills add coreyhaines31/marketingskills --list` to see all available skills before installing. The README notes this works with Claude Code, OpenAI Codex, Cursor, Windsurf, and any agent that supports the Agent Skills spec. - Q: Is Marketing Skills free to use? A: Yes, Marketing Skills is fully open-source and released under the MIT license, per the repository. There is no cost to install or use the skill files. Installation relies on npx, which requires Node.js but no paid account or API key. - Q: What is Marketing Skills best for? A: It is best suited to technical marketers and founders who already use AI coding agents like Claude Code or Cursor and want those agents to apply marketing best practices without manual prompting each session. The skill set spans CRO, copywriting, SEO, paid ads, analytics, lifecycle email, pricing, churn prevention, and more, making it especially valuable for solo builders running growth and marketing from the same agentic workflow. - Q: How does the product-marketing skill act as a foundation for the others? A: Per the README, the product-marketing skill is the shared context layer that every other skill reads first to understand your product, audience, and positioning. This means skills like `cro`, `copywriting`, or `cold-email` tailor their output to your specific product rather than producing generic advice. Setting it up correctly before using other skills is described as the key prerequisite for the system to work as designed. - Q: What are the main limitations of Marketing Skills? A: The skills require an agent runtime that supports the Agent Skills spec, so they will not function in environments that do not load markdown context files. Skill quality and freshness depend on community contributions and repository maintenance. Additionally, an agent that poorly applies or ignores loaded context will see limited benefit regardless of skill quality. - **ui.sh Markup From Image** by ui-sh: Claude skill that turns UI screenshots, Figma exports, and wireframes into semantic, accessible HTML or JSX, no styling included, by design. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-markup-from-image - Source: https://ui.sh/skills/markup-from-image - Install: `npx @uidotsh/install markup-from-image --token=[token]` - Tags: skill, ui, html, jsx, accessibility, semantic-markup, claude, open-source - Pricing: unknown - Features: Convert screenshots, mockups, and wireframes to semantic HTML or JSX; Accessibility-aware element selection baked into the output; Deliberately omits all styling, structure only; Single slash-command invocation with an image file argument; Accepts Figma exports, wireframes, mockups, and screenshots; Integrates with the broader ui.sh agent skill suite - Best for: Converting screenshots, Figma exports, mockups, or wireframes into a clean semantic scaffold before any styling pass; Builders who want to avoid class-bleed and structural debt from AI-generated Tailwind on a first pass; Teams following a structure-first, styling-later workflow with separation of concerns baked in - Outcomes: A single semantic, unstyled HTML or JSX block derived from the input image; Accessible element choices made according to accessibility guidelines, with no styling or component extraction; A clean structural layer ready to pipe into a styling skill like ui.sh Design or ui.sh Canonicalize Tailwind - Caveats: Output is intentionally a starting point, not a finished UI, so a second styling pass is always required; Does not perform component extraction, so you handle componentization yourself; Part of a multi-skill suite, meaning full workflow value depends on pairing it with other ui.sh skills - Cost note: A token from ui.sh is required to use the skill. Specific pricing details are not provided in the entry content. - Q: What is ui.sh Markup From Image? A: Markup From Image is a Claude agent skill from the ui.sh suite, built by the team behind Tailwind CSS and Refactoring UI, that converts UI screenshots, Figma exports, mockups, and wireframes into semantic, unstyled HTML or JSX. It selects appropriate semantic elements with accessibility guidelines in mind and deliberately omits styling and component extraction, so the output is a clean structural scaffold ready for a visual styling pass. - Q: How do I install and use Markup From Image? A: Install it using the ui.sh npx installer with the @uidotsh/install package: run `npx @uidotsh/install markup-from-image --token=`. A ui.sh invite token is required. Once installed, invoke the skill in Claude with a single slash command, for example `/markup-from-image zeplo-homepage.png`, passing the image file as an argument. - Q: Is Markup From Image free or open source? A: No public free tier is listed on ui.sh as of the time this entry was written. Access requires a ui.sh invite token, which you can request at ui.sh. The skill is part of the ui.sh suite and the licensing terms are not detailed in the publicly available documentation. - Q: What is Markup From Image best for? A: It is best for the first step of a UI build: converting a visual reference (screenshot, Figma export, mockup, or wireframe) into a clean, accessible structural scaffold before any styling is applied. The structure-first approach enforces a clean separation between markup and visual design, which prevents AI-generated Tailwind classes from bleeding into the semantic layer during the initial pass. - Q: How does Markup From Image compare to tools that reproduce UIs pixel-for-pixel from images? A: Markup From Image is optimized for semantic correctness and accessibility, not visual fidelity. It intentionally omits styling, spacing, color, and typography reproduction. Tools like ui-from-image (a separate Codex skill) prioritize exact reference-viewport matching for layout, spacing, iconography, and color. Reach for Markup From Image when you want a clean, restyable scaffold; reach for a high-fidelity reproduction tool when 'roughly similar' is not enough. - Q: What are the limitations of Markup From Image? A: The skill outputs unstyled markup only, meaning you need a separate skill or workflow step to add visual design, Tailwind classes, or component structure. It does not attempt to match colors, typography, or spacing from the source image. A ui.sh token is required to install it, and no public free tier is currently listed. For pixel-accurate reproduction, a different toolchain is needed. - **ui.sh Make Responsive** by ui-sh: Agent skill for adapting desktop UIs to mobile, tablet, and desktop breakpoints, built by the makers of Tailwind CSS and Refactoring UI. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-make-responsive - Source: https://ui.sh/skills/make-responsive - Install: `npx @uidotsh/install make-responsive --token=[token]` - Tags: responsive, tailwind, ui, agent-skill, mobile, open-source, cli, design - Pricing: unknown - Features: Adapts desktop UI to mobile, tablet, and desktop breakpoints via /make-responsive command; Fixes iOS Safari focus-zoom by enforcing 16px minimum on text inputs; Adds mobile navigation when none exists in the original layout; Scales body text up on mobile for natural reading without altering desktop styles; Fixes overflow, clipping, awkward wrapping, and cramped controls; Handles responsive behavior for forms, tables, cards, and touch targets; Works with Claude Code, Cursor, Codex, OpenCode, and Amp via MCP; Installable alongside other ui.sh skills in a single npx command - Best for: Teams using AI agents to build UIs who need reliable mobile, tablet, and desktop breakpoint coverage; Builders shipping Tailwind-based UIs who want senior design engineer level responsive fixes baked in; Projects where agents have already generated desktop UIs that need a targeted responsive pass - Outcomes: Overflow, cramped controls, and missing mobile navigation are automatically detected and fixed across breakpoints; iOS Safari zoom-on-focus bug is resolved by enforcing at least 16px on text inputs, a fix generic agents routinely miss; Mobile navigation is added when the desktop layout has none, closing a gap most coding agents skip entirely; Body text is bumped to text-lg on mobile while desktop sizing is preserved, improving reading experience without manual tuning - Caveats: Access is invite-only and the platform is self-described as uncomfortably early by creator Adam Wathan; The skill primitive concept is brand-new and the shape of an AI design toolkit is still being worked out in public; Scope is narrow by design, it fixes responsiveness specifically and is not a general UI agent skill; Builders needing production-stable tooling should consider waiting for a more mature release - Q: What is ui.sh Make Responsive? A: ui.sh Make Responsive is an agent skill that adapts existing desktop-oriented UIs to work across mobile, tablet, and desktop breakpoints. It is part of the ui.sh suite, built by Adam Wathan (creator of Tailwind CSS) and Steve Schoger (co-author of Refactoring UI). The skill targets specific responsive failures that AI coding agents typically miss, such as iOS Safari zoom bugs, missing mobile navigation, and cramped touch targets. It is invoked with the /make-responsive command inside a supported coding agent. - Q: How do I install and use ui.sh Make Responsive? A: Install the skill by running 'npx @uidotsh/install make-responsive --token=[token]' in your project directory, where the token is provided when you gain access to ui.sh. Once installed, trigger it inside your coding agent with the /make-responsive command. The skill then analyzes the UI at mobile, tablet, and desktop sizes and applies responsive fixes automatically. Multiple ui.sh skills can be installed at once by omitting the skill name from the npx command. - Q: Is ui.sh Make Responsive free or open source? A: The pricing model for ui.sh is not disclosed in the available sources. Access to the platform is currently invite-only, and Adam Wathan has described the current state as 'uncomfortably early.' The skill is not listed as open source in any available source material. Builders should check ui.sh directly for current access and pricing details. - Q: What is ui.sh Make Responsive best for? A: The skill is best for retrofitting responsive design onto existing desktop-first UIs, particularly when using a coding agent that would otherwise miss mobile-specific edge cases. It shines at fixing the three things agents most often skip: enforcing 16px minimum on inputs to prevent iOS Safari zoom, adding mobile navigation when none exists, and scaling body text appropriately for mobile reading. It works across Claude Code, Cursor, Codex, OpenCode, and Amp via MCP. - Q: How does ui.sh Make Responsive compare to writing responsive Tailwind by hand or using a generic agent? A: Generic coding agents produce responsive Tailwind classes but routinely miss implementation-level edge cases that a senior design engineer would catch. Per the ui.sh skill page, agents often overlook the iOS Safari focus-zoom issue, skip adding mobile navigation entirely, and fail to adjust touch target sizes. ui.sh Make Responsive encodes those fixes as curated prompts and reference examples authored by the Tailwind CSS and Refactoring UI team, giving the agent a higher baseline than a raw model would achieve on its own. - Q: What are the limitations or risks of using ui.sh Make Responsive? A: The primary limitation is access: ui.sh is invite-only and Adam Wathan has publicly described it as 'uncomfortably early,' signaling that the product is still taking shape. Installation requires a token, so there is no self-serve path without an invite. The skill is also a retrofit tool, meaning it is designed for adapting existing desktop layouts rather than building mobile-first from the start. Builders on a tight deadline who need a stable, widely available tool may want to wait for a more mature release. - **ui.sh Dark Mode Image** by ui-sh: Agent skill that regenerates light-mode raster images as true dark-mode variants using gpt-image-2, for interface builders using Claude Code, Cursor, or Codex. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-dark-mode-image - Source: https://ui.sh/skills/dark-mode-image - Install: `npx @uidotsh/install dark-mode-image --token=[token]` - Tags: dark-mode, image-generation, agent-skill, ui, tailwind, open-ai, raster, invite-only - Pricing: unknown - Features: Regenerates raster images (PNG, etc.) for dark backgrounds via AI image generation; Preserves composition, softness, fades, and overall character of the original; Handles screenshots, product mockups, illustrations, photos, and textures; Produces real dark-mode image files, not CSS filter approximations; Powered by OpenAI gpt-image-2 through the Codex model requirement; Integrates into existing coding agent workflows via the ui.sh installer; Single-command invocation: /dark-mode-image ; Part of a broader ui.sh skill suite for AI-assisted interface building - Best for: Teams shipping dark mode who need raster image assets that look designed rather than filtered; Builders using Claude Code, Cursor, Codex, OpenCode, or Amp who want agent-driven image conversion; Projects with screenshots, product mockups, illustrations, photos, or texture assets needing dark variants; Developers who want to avoid hue-shifting and brand color damage caused by CSS filter invert hacks - Outcomes: A genuine dark-mode raster variant that preserves the original image size, composition, softness, fades, and character; A single-command workflow via /dark-mode-image pointing at a file, reducing a tedious manual asset production step; Results that look intentionally designed for dark surfaces, not inverted or hue-shifted by a CSS workaround - Caveats: ui.sh is invite-only and described by its creator as uncomfortably early, so expect rough edges and limited access; Hard dependency on Codex with gpt-image-2 narrows compatible agent setups without extra configuration; Raster-only scope means SVG, components, and CSS assets are out of range for this specific skill; The sibling skill Add Dark Mode must be used separately for code and component theming - Q: What does ui.sh Dark Mode Image actually do? A: ui.sh Dark Mode Image is an agent skill that converts light-mode raster images into dark-mode variants using AI image generation. It runs through Codex, which uses OpenAI's gpt-image-2 model, and produces a new image file adapted for dark surfaces. Critically, it generates a real image asset rather than approximating the effect with a CSS filter, so the result preserves the original's composition, softness, and visual character. - Q: How do I install and use this skill? A: Install it via the ui.sh npx installer by running `npx @uidotsh/install dark-mode-image --token=[your-token]`. Once installed, invoke it inside your coding agent with `/dark-mode-image ` pointing at the raster image you want to adapt. You need a valid ui.sh token, which requires an invite, since the platform is currently invite-only. - Q: Is ui.sh Dark Mode Image free or open source? A: The sources do not specify a price or license for this skill. Access to ui.sh requires an invite, and installation requires a token, suggesting it is not fully open. Pricing details are not publicly stated in the available documentation. - Q: What is this skill best for? A: This skill is best for interface builders who have light-mode raster assets (screenshots, product mockups, illustrations, photos, backgrounds, or textures) that need proper dark-mode counterparts. It is the right tool when CSS filter hacks are producing unacceptable results and you need image files that look intentionally designed for a dark surface. - Q: How does this compare to the ui.sh Add Dark Mode skill? A: Dark Mode Image and Add Dark Mode solve different parts of the dark mode problem. Add Dark Mode works on UI code and component theming, handling color tokens, CSS variables, and Tailwind configuration. Dark Mode Image handles raster asset files specifically, regenerating the image itself for dark backgrounds. For a full dark mode implementation you would likely use both, reaching for Dark Mode Image only when raster assets are involved. - Q: What are the main limitations of this skill? A: The skill only handles raster images: SVG files and CSS-based visuals are out of scope. It has a hard dependency on Codex with OpenAI's gpt-image-2 model, so agent setups that don't include that model won't work. Additionally, ui.sh is currently invite-only and described by its creator as 'uncomfortably early,' meaning the platform is actively evolving and some rough edges should be expected. - **ui.sh Add Dark Mode** by ui-sh: Agent skill for adding thoughtfully designed dark mode to existing UIs, balances contrast across text, surfaces, borders, and images for Claude Code, Cursor, Codex, and more. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-add-dark-mode - Source: https://ui.sh/skills/add-dark-mode - Install: `npx @uidotsh/install add-dark-mode --token=[token]` - Tags: dark-mode, ui, tailwind, agent-skill, open-source, design, css, cli - Pricing: unknown - Features: Adds dark mode to existing light UIs via a single slash command; Adjusts text, backgrounds, borders, and shadows for correct contrast; Scans codebase for images, illustrations, screenshots, and SVGs needing dark variants; Delegates raster image conversion to the companion dark-mode-image skill; Supports targeted image conversion with /dark-mode-image ; Integrates with Codex image generation model for automated dark-mode image output; Agent-agnostic: works with Claude Code, Cursor, Codex, OpenCode, and Amp; Installed via npx CLI with a ui.sh token - Best for: Teams with a finished light-mode UI who want dark mode that looks designed rather than auto-inverted; Builders already using Claude Code, Cursor, Codex, OpenCode, or Amp who want to stay in their agent workflow; Projects with mixed assets, raster images, illustrations, and SVGs that need per-asset dark treatment - Outcomes: Text, backgrounds, borders, and shadows adjusted for appropriate contrast across light and dark modes; Raster images, illustrations, screenshots, and SVGs scanned and handed off to the companion dark-mode-image skill for variant generation; Codex users get automatic dark-mode-optimized raster generation via the image generation model; A separation of concerns where surface styling and pixel-level image adaptation are handled by distinct, focused skill invocations - Caveats: ui.sh is invite-only and requires a token for the npx installer; The platform is early-stage and still being shaped in public, per the creator; Image work is delegated to a companion dark-mode-image skill, which must be available in your setup; The skill primitive itself is relatively new with limited track record in production environments - Q: What is ui.sh Add Dark Mode? A: ui.sh Add Dark Mode is a curated agent skill that retrofits a thoughtfully designed dark mode onto an existing light UI. Rather than inverting colors, it adjusts text, backgrounds, borders, and shadows to maintain appropriate contrast in both modes. It is part of the broader ui.sh suite, built by Adam Wathan and Steve Schoger, and runs inside coding agents like Claude Code, Cursor, Codex, OpenCode, and Amp. - Q: How do I install and use this skill? A: Install it via the npx ui.sh installer: `npx @uidotsh/install add-dark-mode --token=`. Once installed, invoke it inside your agent session with the slash command `/add-dark-mode`. To convert a specific image, use `/dark-mode-image filename.jpg`. Multiple skills can be installed at once by omitting the skill name from the install command. - Q: Is ui.sh Add Dark Mode free or open source? A: The sources do not specify a public price or an open-source license for ui.sh Add Dark Mode. Access requires a ui.sh invite token, and the platform is currently invite-only. Builders should check ui.sh directly for current access and pricing details. - Q: What is this skill best for? A: Add Dark Mode is best for projects that already have a solid light-mode UI and need dark mode added without manual color audit work. It is especially useful when the codebase includes raster images, illustrations, or SVGs that also need dark-mode variants, since the skill delegates that image work automatically to the companion dark-mode-image skill. It works across any agent that supports MCP, including Claude Code, Cursor, and Codex. - Q: How does this compare to manually implementing dark mode or using a generic skill? A: Generic dark mode implementations typically rely on CSS class toggles or simple color inversions that produce poor contrast and washed-out images. The ui.sh skill, built by the Tailwind CSS and Refactoring UI authors, applies design judgment to text hierarchy, surface colors, borders, and shadows rather than just flipping values. A separate community skill ('Dark Mode Implementer' on claudemarketplaces.com) covers Tailwind class strategy, CSS variables, and React context with SSR hydration, that alternative is better suited when you need a full React theme provider with localStorage persistence from scratch. - Q: What are the limitations or risks of using this skill? A: The platform is invite-only and Adam Wathan himself describes it as 'uncomfortably early,' so API stability and long-term support are not guaranteed. Dark-mode image generation requires Codex's image generation model, which may not be available in all setups. The skill also requires a valid ui.sh token, making it unavailable for fully offline or self-hosted workflows. - **ui.sh Canonicalize Tailwind** by ui-sh: Agent skill for Tailwind CSS cleanup: sorts, deduplicates, and resolves conflicting utility classes inside Claude Code, Cursor, and other coding agents. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-canonicalize-tailwind - Source: https://ui.sh/skills/canonicalize-tailwind - Install: `npx @uidotsh/install canonicalize-tailwind --token=[token]` - Tags: tailwind, css, agent-skill, mcp, ui, open-source, cli, code-cleanup - Pricing: unknown - Features: Sorts Tailwind utility classes into canonical order; Removes duplicate classes from class strings; Collapses shorthand utilities where applicable; Resolves conflicting utilities while keeping visual output identical; Applies cleaned class lists and runs relevant checks; Invocable via /canonicalize-tailwind inside an MCP-compatible coding agent; Outputs results in text, JSON, or line-delimited JSON (via the underlying CLI subcommand); Works with Claude Code, Cursor, Codex, OpenCode, and Amp - Best for: Teams where multiple agents or developers touch the same Tailwind components, causing class string entropy; Pre-PR cleanup workflows to strip conflicting and redundant utilities before human review; Codebases that have grown beyond single-author control and carry silent utility conflicts like stacked p- and px- overrides - Outcomes: Tailwind class strings are sorted, deduplicated, shorthand-collapsed, and conflict-resolved in a single pass; Visual output is guaranteed unchanged, so cleanup carries no regression risk; Cleaner diffs and less noise for human reviewers on PRs touched by agent-assisted iteration - Caveats: Currently invite-only, requiring a token from ui.sh before the skill can be installed or used; Distinct from prettier-plugin-tailwindcss, which only sorts and does not resolve conflicts or collapse shorthands; The underlying canonicalize logic was merged into Tailwind CSS core on March 11, 2026, confirming first-party alignment - Q: What is ui.sh Canonicalize Tailwind? A: ui.sh Canonicalize Tailwind is an agent skill that sorts, deduplicates, collapses shorthands, and resolves conflicting Tailwind CSS utility classes without changing the visual output. It runs as a task-oriented prompt and workflow inside MCP-compatible coding agents such as Claude Code, Cursor, Codex, OpenCode, and Amp. It is part of the ui.sh skill suite created by Adam Wathan (creator of Tailwind CSS) and Steve Schoger (co-author of Refactoring UI). - Q: How do I install and run the Canonicalize Tailwind skill? A: Install the skill by running `npx @uidotsh/install canonicalize-tailwind --token=[token]` in your project, replacing `[token]` with your ui.sh invite token. Once installed, invoke it by typing `/canonicalize-tailwind` inside your coding agent. The skill then sorts, deduplicates, collapses, and resolves your Tailwind class strings, applies the changes, and runs relevant checks automatically. - Q: Is ui.sh free, and do I need a paid plan? A: ui.sh is invite-only and currently free to access with an invite token; pricing tiers are not publicly disclosed. You must request an invite at ui.sh to obtain a token before installing any skill. Because the platform is described by its creator as 'uncomfortably early,' the pricing model may change as the product matures. - Q: What is Canonicalize Tailwind best suited for? A: It is best suited as a pre-PR cleanup step in codebases where coding agents have been writing or editing Tailwind class strings at pace. Agents often stack utility overrides (for example, two conflicting text colors or layered padding shorthands) rather than replacing them; Canonicalize Tailwind collapses that noise before it reaches a human reviewer. It is also valuable on any Tailwind project with multiple contributors where class-string hygiene has drifted. - Q: How does Canonicalize Tailwind compare to prettier-plugin-tailwindcss? A: Canonicalize Tailwind goes further than `prettier-plugin-tailwindcss` in two key ways: it resolves conflicting utilities and collapses redundant shorthands, whereas the Prettier plugin only sorts classes into Tailwind's recommended order. If your concern is purely sort order for consistency, the Prettier plugin is simpler to wire into a CI pipeline. If you also need conflict resolution and shorthand collapsing, especially after heavy agent-assisted editing, Canonicalize Tailwind is the better fit. A `tailwindcss canonicalize` CLI subcommand with the same logic was merged into Tailwind CSS core on March 11, 2026 (PR #19783), so the underlying capability is becoming part of the framework itsel - Q: What are the limitations or risks of using this skill? A: The skill requires a ui.sh invite token, so you cannot use it without going through the invite process. Tailwind CSS must already be installed in your project for the skill to function; it will not work on plain CSS or other utility frameworks. The platform is self-described as 'uncomfortably early,' meaning the skill's interface or behavior may change as ui.sh evolves. Pricing and long-term availability are not publicly disclosed. - **ui.sh Brand Kit** by ui-sh: ui.sh Brand Kit skill: generate a visual brand direction board with site mockups, typography, and color from a single prompt, for Codex-powered coding agents. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-brand-kit - Source: https://ui.sh/skills/brand-kit - Install: `npx @uidotsh/install brand-kit --token=[token]` - Tags: branding, ui, design, tailwind, codex, open-source, agent - Pricing: unknown - Features: Generates a brand direction board from a plain-English product idea prompt; Produces two site mockups plus typography and color guidance as a single image; Accepts aesthetic references and attached images as inspiration; Supports iterative prompting to steer font, color, and mood; Runs on Codex via OpenAI gpt-image-2 model; Installed via npx into any supported coding agent project; Works with Claude Code, Cursor, Codex, OpenCode, and Amp (per ui.sh agent support) - Best for: Teams starting a new product who want a coding agent to build UI with a coherent visual identity from day one; Builders frustrated by generic AI palettes and safe font choices who want a concrete visual target before writing components; Situations where brand direction needs to be communicated to an agent before any code is written - Outcomes: A single image containing two site mockups plus typography and color guidance to serve as an agent reference; A creative direction board generated from a plain-English product idea prompt, steerable with aesthetic or mood cues; An image-based visual brief that can also be seeded from attached screenshots of existing sites or competitor aesthetics - Caveats: Output is one image, not a design token file; hex values and type scales require manual extraction; Gated behind a ui.sh token and the platform is invite-only, described by its creator as uncomfortably early; Scope is intentionally a direction board, not a finished design system, which may be too loose for mature product teams; Requires the Codex model with OpenAI gpt-image-2, so teams not using that model stack cannot run it - Q: What is ui.sh Brand Kit? A: ui.sh Brand Kit is an agent skill that converts a plain-English product idea into a visual brand direction board. The output is a single generated image containing two site mockups alongside compact typography and color guidance. It is part of the ui.sh skill suite, created by Adam Wathan and Steve Schoger, the people behind Tailwind CSS and Refactoring UI. - Q: How do I install and use Brand Kit? A: Install it by running `npx @uidotsh/install brand-kit --token=[your-token]` in your project directory. Once installed, invoke it with a slash command: `/brand-kit [your product idea]`. You can steer the output by including aesthetic references, mood cues like 'dark aesthetic', or follow-up prompts like 'try again with a different font pairing' to get more varied results. - Q: Is ui.sh Brand Kit free or open source? A: The available sources do not disclose specific pricing. Access requires a ui.sh invite token, and the platform is described as invite-only. The creator has called the current state 'uncomfortably early,' suggesting it is an active commercial product in limited access, but exact pricing is not published in the available sources. - Q: What is Brand Kit best suited for? A: Brand Kit is best for early-stage product work where no visual identity exists yet and you want to give a coding agent a concrete aesthetic target before writing any UI components. It is especially useful for quickly exploring different brand directions by iterating prompts, and works well when you are about to build a marketing site or product UI from scratch. - Q: How does Brand Kit compare to extracting a brand from existing screenshots? A: Brand Kit generates a brand direction forward from a product idea prompt, while a screenshot-based extraction approach (as described in the Genesys newsletter) reverse-engineers visual identity from an existing live site. Brand Kit is the right tool when nothing exists yet; screenshot-based extraction is better when a brand is already live and you want to systematize what is already there. The two approaches are complementary at different stages of a product's life. - Q: What are Brand Kit's main limitations? A: The skill outputs a single raster image, not a structured file of design tokens, so hex values and font names must be extracted manually if you want them in your codebase. The Codex model using OpenAI's gpt-image-2 is required; no other model is supported for this skill. Access is gated behind a ui.sh invite token, and agents tend to default to familiar fonts unless you explicitly prompt for alternatives. - **ui.sh Ideas** by ui-sh: ui.sh Ideas skill for AI coding agents: generate and compare multiple UI design directions in the browser before committing to one. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-ideas - Source: https://ui.sh/skills/ideas - Install: `npx @uidotsh/install ideas --token=[token]` - Tags: ui, design, agent, tailwind, mcp, open-source, browser-preview - Pricing: unknown - Features: Generates multiple distinct UI design concepts in a single agent run; In-browser option picker for side-by-side comparison of concepts; Clearly labeled concepts; supports selecting one or merging elements from several; Slash-command invocation inside MCP-compatible coding agents; Combines with ui.sh Design skill to apply design guidelines to every concept; Works with Claude Code, Cursor, Codex, OpenCode, and Amp; Single npx install command with token-based project setup - Best for: Teams that want to explore multiple UI directions before committing any design to the codebase; Builders who default to the first AI-generated output and want a structured way to break that habit; Designers and developers already using an MCP-compatible coding agent who want divergent exploration baked in - Outcomes: Multiple distinct UI concepts generated in parallel and surfaced side by side in the browser for comparison; An in-agent option picker that lets you select a direction or mix elements from multiple concepts without context switching; A design exploration loop that stays entirely inside the coding agent session, from prompt to picked direction - Caveats: Currently invite-only with no confirmed public release timeline; The team describes the product as uncomfortably early, signaling limited stability and documentation; The skill primitive it depends on is a recent addition to the agent ecosystem and may shift; Concept variety is strongest when paired with the ui.sh Design skill; solo use may produce less differentiated options - Q: What is ui.sh Ideas? A: ui.sh Ideas is an agent skill that generates multiple distinct UI design concepts for a page or section and displays them in the browser with a picker so you can compare directions before committing to one. It is part of the ui.sh suite built by Adam Wathan (Tailwind CSS) and Steve Schoger (Refactoring UI). The skill runs inside MCP-compatible coding agents like Claude Code, Cursor, Codex, OpenCode, and Amp. After the agent generates the concepts, you select the direction you want to keep, or ask it to blend elements from several. - Q: How do I install and use ui.sh Ideas? A: Install the skill by running `npx @uidotsh/install ideas --token=` in your project. Once installed, invoke it inside your agent session with a slash command such as `/ideas for a new testimonial section after the hero`. The agent generates multiple concepts and inserts an in-browser option picker. To apply the ui.sh design guidelines to every concept, combine it with the Design skill using `/design /ideas generate three testimonial section concepts`. - Q: Is ui.sh Ideas free or open source? A: ui.sh is currently invite-only, and its pricing is not publicly listed in the available sources. Installation requires a token, which suggests access is gated. The team describes the project as 'uncomfortably early,' so pricing and access models may evolve. Check ui.sh directly for current invite and pricing details. - Q: What is ui.sh Ideas best for? A: ui.sh Ideas is best for situations where you want to explore several UI directions before locking in on one, rather than defaulting to the first output the agent produces. It is particularly useful for key page sections like heroes, testimonials, or pricing blocks where layout and visual direction meaningfully affect user experience. Pairing it with the ui.sh Design skill ensures each concept follows a coherent design system rather than just generating arbitrary variations. - Q: How does ui.sh Ideas compare to just prompting an agent directly? A: Prompting an agent directly typically produces one output per run, and iterating on direction requires multiple back-and-forth exchanges with no side-by-side comparison. ui.sh Ideas structures the generation process to produce several distinct concepts in a single run and presents them in the browser with a labeled picker, so the comparison happens visually rather than through text descriptions. The skill also encodes design expertise from the Tailwind CSS and Refactoring UI team into the prompts, which nudges the model away from generic AI-looking output. - Q: What are the limitations of ui.sh Ideas? A: ui.sh is invite-only at launch, so access is not guaranteed. The team openly calls the current release 'uncomfortably early,' meaning the skill and surrounding platform are still being shaped. The skill requires an npx install step and a token per project, and it only works inside MCP-compatible coding agents. Builders who need a fully stable, documented workflow should factor the early-stage maturity into their decision. - **ui.sh Design** by ui-sh: Claude/Codex/Cursor skill from the Tailwind CSS team that upgrades AI-generated UI from generic to designer-quality, in any existing project. - Analog: https://analoghq.ai/es/ui-sh/skills/ui-sh-design - Source: https://ui.sh/skills/design - Install: `npx @uidotsh/install design --token=[token]` - Tags: skill, ui, design, claude, codex, cursor, tailwind, open-source - Pricing: unknown - Features: Slash-command activation via /design in any supported coding agent; Guides layout, hierarchy, color, spacing, typography, and component decisions; Avoids common AI UI tells: purple palettes, text gradients, unnecessary card boxing; Builds within the project's existing framework, components, and conventions; Checks output across responsive breakpoints and interaction states; Supports parallel multi-concept generation when combined with the ideas skill; Works with Claude Code, Codex, Cursor, OpenCode, and Amp via MCP; Installs via a single npx command with a project-scoped token - Best for: Teams using Claude Code or Codex to ship UI who want output that looks senior-designer reviewed, not AI-interpolated; Builders tired of purple palettes, text gradients, and card-heavy layouts in AI-generated interfaces; Projects that already have an existing framework, components, and conventions the agent can build within; Developers who want hierarchy, color, spacing, and typography craft baked into agent output from the start - Outcomes: Agent output that avoids the obvious AI-designed fingerprint across layout, color, and typography; UI that is checked across responsive breakpoints and interaction states as part of the build step; More accessible implementations per the project's own framing; Ability to spin up multiple design concepts in parallel when paired with the ideas skill - Caveats: Currently invite-only, so teams must join a waitlist before evaluating; Described by the creator himself as uncomfortably early, meaning conventions and surface area are still evolving; The skill primitive the tool relies on is itself new, adding a second layer of platform immaturity to consider; Best results are tied to Claude Code with Opus, so other agent setups may see weaker output - Q: What is ui.sh Design? A: ui.sh Design is an AI agent skill that gives coding agents like Claude Code, Codex, and Cursor the design judgment of a senior designer when generating UI. It works by injecting curated prompts, guidelines, and reference examples into the agent's context, steering decisions about layout, hierarchy, color, spacing, and typography. It was created by Adam Wathan (Tailwind CSS) and Steve Schoger (Refactoring UI), and is part of a broader suite of ui.sh skills for interface builders. - Q: How do I install and use the Design skill? A: Install it by running `npx @uidotsh/install design --token=` inside your project. Once installed, prefix any UI prompt with `/design` to activate the skill, for example `/design Create a login page for a SaaS application`. The skill works within your existing framework, components, and conventions, and checks results across responsive breakpoints and interaction states automatically. - Q: Is ui.sh free or open source? A: ui.sh requires a token to install, indicating it is access-gated rather than freely open. The platform is currently invite-only, and pricing details are not publicly disclosed in the available sources. Wathan has described the current state as 'uncomfortably early,' so the commercial model may still be taking shape. - Q: What is the Design skill best for? A: The Design skill is best for developers and teams who are already building UI with an AI coding agent and want to move the output quality from 'obviously AI-generated' to 'looks like a designer reviewed it.' It actively steers agents away from common AI tells like purple-heavy palettes, text gradients, and unnecessary card boxing, and it works within whatever framework and component library the project already uses. - Q: How does ui.sh Design compare to using a standalone AI design tool? A: ui.sh Design sits inside your existing agent workflow rather than requiring a separate design tool or IDE. Unlike tools such as TypeUI (which also offers design skills for Claude, Codex, and Cursor but as a standalone catalog), ui.sh integrates directly via MCP and a shell installer, meaning the skill travels with your project and respects your existing codebase conventions. The tradeoff is that ui.sh is invite-only and early, while alternatives may offer more immediate access. - Q: What are the limitations or risks of using ui.sh Design? A: The biggest limitation is access: ui.sh is invite-only and the creators describe it as 'uncomfortably early,' meaning stability, coverage, and conventions are still evolving. The best results are with Claude Code running the Opus model; other agents and models may produce weaker improvements. The skill primitive itself is new, so the surface area of what it covers will change as the platform matures. - **PM Skills Marketplace** by phuryn: Open-source PM skills marketplace: 68 AI skills and 42 workflows across 9 Claude plugins for product managers doing discovery, strategy, execution, and launch. - Analog: https://analoghq.ai/es/phuryn/skills/pm-skills - Source: https://github.com/phuryn/pm-skills - Install: `claude plugin marketplace add phuryn/pm-skills claude plugin install pm-toolkit@pm-skills codex plugin marketplace add phuryn/pm-skills codex plugin add pm-toolkit@pm-skills` - Repo: https://github.com/phuryn/pm-skills - Tags: open-source, cli, claude, product-management, agent, workflows - Pricing: free - Features: 68 skills encoding named PM frameworks (OST, JTBD, Lean Canvas, SWOT, PESTLE, Porter's Five Forces, Ansoff Matrix); 42 chained workflows invoked via slash commands (/discover, /write-prd, /strategy, /plan-launch, /north-star); 9 domain plugins: discovery, strategy, market research, data analytics, marketing growth, GTM, execution, AI shipping, t; Auto-loading skills that activate without explicit invocation when relevant; Native install into Claude Code CLI, Claude Cowork, and Codex CLI; Skills-only copy mode for Cursor, Gemini CLI, OpenCode, and Kiro; Commands chain sequentially and suggest the next logical command on completion; MIT-licensed and open-source with PRs welcome - Best for: PMs using Claude Code or Claude Cowork who want framework-driven decisions baked into daily AI workflows; Teams wanting Teresa Torres, Marty Cagan, or Alberto Savoia methodologies as executable commands, not reading material; Builders who need structured discovery, strategy, or GTM workflows without assembling prompts from scratch; Solo PMs who want guided multi-step workflows that surface the next logical step automatically - Outcomes: 68 skills and 42 chained workflows across 9 PM domain plugins installed in under two minutes; Slash commands like /discover that auto-chain brainstorm, assumption, prioritization, and experiment steps in sequence; Coverage across discovery, product strategy, market research, data analytics, GTM, execution, and AI shipping domains; Frameworks like Opportunity Solution Trees, Lean Canvas, Porter's Five Forces, and JTBD scripts available on demand; Each completed command surfaces the next logical command, guiding the PM workflow forward without manual navigation - Caveats: Slash command chaining is Claude-specific; Codex CLI users must describe workflows in plain language or convert commands manually; Non-Claude tools like Cursor, Gemini CLI, OpenCode, and Kiro receive skills only, not guided multi-step workflows; Skills load automatically when Claude judges them relevant, so trigger behavior depends on Claude's own judgment; No hosted interface; installation requires CLI access and manual setup per tool outside Claude Cowork - Q: What is PM Skills Marketplace? A: PM Skills Marketplace is an open-source library of 68 PM skills and 42 chained workflows packaged into 9 plugins for Claude Code and Claude Cowork. Each skill encodes a named PM framework, from Teresa Torres's Opportunity Solution Trees to Alberto Savoia's lean pretotypes, so you get structured, repeatable PM processes inside your AI assistant rather than freeform text generation. It is MIT-licensed and hosted on GitHub at phuryn/pm-skills. - Q: How do I install it? A: In Claude Cowork, open Customize, go to Browse plugins, and add the marketplace from GitHub using 'phuryn/pm-skills', all 9 plugins install automatically. In Claude Code CLI, run 'claude plugin marketplace add phuryn/pm-skills' and then install each plugin individually with 'claude plugin install pm-toolkit@pm-skills' (and so on for the other 8). For Codex CLI the same two-step pattern applies using 'codex plugin marketplace add'. For Cursor, Gemini CLI, OpenCode, or Kiro, you copy the skill folders manually into the tool's designated skills directory. - Q: Is PM Skills Marketplace free or open source? A: Yes, the phuryn/pm-skills repository is open source under the MIT license, which means you can use, modify, and distribute it freely. The underlying AI that runs the skills (Claude or Codex) requires its own subscription from Anthropic or OpenAI. There is no additional charge for the marketplace itself. - Q: What is it best for? A: PM Skills Marketplace is best for product managers who regularly do discovery, strategy definition, PRD writing, launch planning, or metrics design inside Claude Code or Cowork. The 9 plugins cover the full PM lifecycle, and the chained commands (/discover, /strategy, /write-prd, /plan-launch, /north-star) let you move from raw idea to structured artifact without manually orchestrating steps. Teams wanting to standardize PM rigor across AI-assisted work also benefit from a shared plugin baseline. - Q: How does it compare to just prompting Claude without skills? A: Without skills, Claude draws on general knowledge and produces generic text responses. With PM Skills Marketplace loaded, Claude gains domain-specific frameworks encoded as skills (Impact x Risk matrices, JTBD interview scripts, Opportunity Solution Trees, Porter's Five Forces) and chained commands that enforce a multi-step process. The README frames this as the difference between 'text' and 'structure', the skills ensure the methodology is applied consistently, not just described. - Q: What are the main limitations? A: Slash commands (/discover, /write-prd, etc.) are Claude-specific and do not run natively as commands in Codex CLI, Cursor, Gemini CLI, or OpenCode. On Codex, you can describe workflows in plain language or ask the model to convert command files into Codex-native skills, but the README notes this is a best-effort conversion. On other tools you get the PM frameworks via skill files but lose the guided, chained workflow experience. Additionally, the README recommends installing whole plugins rather than individual skills, since most workflows depend on sibling skills within the same plugin. - **Loop Library** by forward-future: A catalog of repeatable AI agent workflows with built-in feedback loops, plus an installable skill for finding, adapting, and designing your own loops. - Analog: https://analoghq.ai/es/forward-future/skills/loop-library - Source: https://signals.forwardfuture.ai/loop-library/ - Install: `npx skills add Forward-Future/loop-library --skill loop-library -g` - Repo: https://github.com/Forward-Future/loop-library - Tags: open-source, agent, cli, workflow, prompt-library, agentic, mit-license - Pricing: free - Features: Browse 69+ agent loops across Engineering, Evaluation, Operations, Content, and Design; Each loop includes a copy-ready prompt, verify criteria, feedback steps, and notes; Installable skill with five modes: Discover, Find, Loop Doctor, Adapt, Design; Live catalog queried in real time by the skill when recommending loops; Machine-readable endpoints: JSON catalog, plain-text catalog, llms.txt, and agent guide; Loop Doctor audits and repairs weak checks, unsafe actions, or unclear stopping behavior; Discovery inspects codebases and coding threads for recurring work patterns; Compatible with Codex, Cursor, and Claude Code via a single npx install command - Best for: Teams using Codex, Cursor, or Claude Code who want agents to iterate reliably instead of making one-shot guesses; Builders who need pre-built feedback loops with clear success criteria, stopping conditions, and next-step logic; Developers looking to identify repeated work in a codebase and systematize it into a measurable agent loop; Anyone who wants to audit, repair, or adapt an existing agent prompt into a proper feedback loop - Outcomes: Access to 69+ curated, copy-ready agent loops each with a Use When statement, prompt, Verify section, Steps view, and risk Notes; An installable skill adding five guided modes: Discover, Find, Loop Doctor, Adapt, and Design; Machine-readable JSON catalog and llms.txt endpoints so agents can read the catalog directly without the skill; A structured way to make agent work measurable and repeatable by defining success evidence and stopping conditions upfront - Caveats: Loops are deliberately bounded and will not start schedules, deploy code, delete data, send messages, or grant permissions autonomously; Discovery mode requires at least two distinct thread occurrences before labeling work as repeated, not just codebase evidence alone; If coding-thread history is inaccessible, the skill falls back to codebase evidence only and discloses the limitation; Unverified code patterns are labeled as potential loops, not confirmed recurring work - Cost note: The catalog is free to browse and copy with no account or install required. The installable skill appears to be free via npx; no paid tiers are mentioned in the entry. - Q: What is Loop Library? A: Loop Library is a curated catalog of 69+ practical AI agent prompts structured as feedback loops, each with a clear goal, a verification step, next-step logic, and a stopping condition. It exists as a public browsable website (no account needed) and an optional installable skill for Codex, Cursor, and Claude Code. The project is built by Forward Future and released under the MIT License. - Q: How do I install and use the Loop Library skill? A: You need Node.js and npx. Run `npx skills add Forward-Future/loop-library --skill loop-library --agent claude-code -g -y` to install for Claude Code, swapping `claude-code` for `codex` or `cursor` as needed. Once installed, invoke it with `/loop-library` followed by a plain-language request in Claude Code or Cursor, or choose it from `/skills` in Codex. If your agent was already open, restart it after install for the skill to appear. - Q: Is Loop Library free or open source? A: Loop Library is free and released under the MIT License, per the README. The public catalog website requires no account or installation to browse and copy loop prompts. The installable skill is also free and pulls from the same live catalog. - Q: What is Loop Library best for? A: Loop Library fits best when agent work is recurring and the first attempt is unlikely to be the final answer: fixing production errors, improving test coverage, keeping documentation current, or sweeping SEO gaps. The library's loops are deliberately bounded, so they suit teams who want measurable, repeatable agent workflows rather than open-ended runs. The skill's Discover mode is especially useful for finding repeated engineering work in your own codebase and turning it into a reusable loop. - Q: How does Loop Library compare to just writing a prompt yourself? A: A hand-written prompt typically asks an agent to do something once, leaving verification and stopping behavior implicit. Loop Library prompts encode the feedback cycle directly: what to measure, what counts as success, what to do when an attempt fails, and when to hand control back to a person. The library also provides Loop Doctor, which audits an existing prompt or loop for weak checks, unsafe actions, or unclear stopping behavior and repairs only the material problems, something a blank-slate prompt approach does not provide. - Q: What are the limits or risks of using Loop Library? A: The skill does not take production actions on its own: it will not start schedules, deploy code, delete data, send messages, or grant permissions without an explicit request. Discovery requires at least two distinct thread occurrences before marking work as truly repeated, and a code pattern without run history is labeled a potential loop rather than confirmed recurrence. If your agent cannot access thread history, the skill falls back to codebase evidence alone and notes the limitation explicitly. - **Anthropic Skills** by anthropics: La colección pública de Agent Skills de ejemplo para Claude de Anthropic: carpetas autocontenidas de instrucciones, scripts y recursos que abarcan tareas creativas, técnicas y empresariales, incluidas las skills de documentos que impulsan las capacidades de archivos de Claude. - Analog: https://analoghq.ai/es/anthropics/skills/anthropic-skills - Source: https://github.com/anthropics/skills - Repo: https://github.com/anthropics/skills - Tags: open-source, claude, agent, anthropic, cli, document-processing, enterprise - Pricing: freemium - Features: Colección oficial de Anthropic de Agent Skills de ejemplo para Claude; Cada skill es una carpeta `SKILL.md` autocontenida que Claude carga dinámicamente; Abarca skills de ejemplo creativas, técnicas y empresariales; Incluye las skills de documentos `docx`, `pdf`, `pptx` y `xlsx`; Incluye la especificación de Agent Skills y una plantilla de skill; Instalable como un marketplace de plugins de Claude Code; También utilizable en Claude.ai y a través de la Claude API - Best for: Aprender a crear Agent Skills; Implementaciones de referencia de skills de documentos; Añadir capacidades de documentos (`docx`/`pdf`/`pptx`/`xlsx`) a Claude - Outcomes: Patrones para skills `SKILL.md` autocontenidas; Conjuntos de skills de documentos y de ejemplo instalables; La especificación de Agent Skills y una plantilla - Caveats: Proporcionadas para demostración y educación; pruébalas antes de depender de ellas; Las skills de documentos tienen código fuente disponible, no son completamente de código abierto - Cost note: Gratuito; muchas skills bajo Apache 2.0, skills de documentos con código fuente disponible. - Q: ¿Qué contiene este repositorio? A: Las Agent Skills de ejemplo para Claude de Anthropic: carpetas `SKILL.md` autocontenidas que abarcan tareas creativas, técnicas y empresariales, además de la especificación de Agent Skills y una plantilla de skill. - Q: ¿Son estas las skills de documentos que usa Claude? A: Sí. Incluye las skills `docx`, `pdf`, `pptx` y `xlsx` que impulsan las capacidades de documentos de Claude; estas están disponibles como código fuente de referencia, mientras que muchas otras skills son de código abierto bajo Apache 2.0. - Q: ¿Cómo las uso? A: Registra el repositorio como un marketplace de plugins de Claude Code e instala los conjuntos de skills de documentos o de ejemplo; las skills de ejemplo también están disponibles en los planes de pago de Claude.ai y a través de la Claude API. - **Skills for Real Engineers** by mattpocock: Habilidades de agente para ingeniería real de Matt Pocock, en lugar de vibe coding: habilidades pequeñas, componibles e independientes del modelo (instalables mediante skills.sh), con una configuración guiada e integración con el gestor de incidencias. - Analog: https://analoghq.ai/es/mattpocock/skills/skills-for-real-engineers - Source: https://github.com/mattpocock/skills - Install: `npx skills` - Repo: https://github.com/mattpocock/skills - Tags: agent, open-source, claude-code, tdd, domain-modeling, cli, composable - Pricing: free - Features: Habilidades de agente pequeñas, componibles e independientes del modelo; Se instala mediante skills.sh con un comando de configuración único; Las habilidades de interrogación te alinean con el agente antes de escribir cualquier código; Ciclos de TDD rojo-verde-refactorización y de diagnóstico de errores; Habilidades de arquitectura para diseñar módulos profundos y rescatar código desordenado; Integración con el gestor de incidencias mediante GitHub, Linear o archivos locales; Divididas en orquestadores invocados por el usuario y disciplinas invocadas por el modelo - Best for: Alinear un agente antes de que escriba código; Aplicar TDD y una depuración disciplinada; Evitar que las bases de código construidas con IA se conviertan en una bola de barro - Outcomes: Mejor alineación del agente mediante sesiones de interrogación; Un lenguaje de proyecto compartido que reduce tokens y deriva; Arquitectura más saludable con el tiempo - Caveats: Habilidades componibles, no un sistema listo para usar; El valor depende de adoptar los flujos de trabajo de forma consistente - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Para qué sirven estas habilidades? A: Para ingeniería real con agentes de codificación: apuntan a cuatro modos de fallo comunes, el desalineamiento del agente, la verbosidad, el código roto y la degradación arquitectónica, mediante habilidades de interrogación, lenguaje compartido, TDD y diseño. - Q: ¿Cómo las instalo? A: Ejecuta npx skills add mattpocock/skills, selecciona las habilidades y el asistente setup-matt-pocock-skills, y luego ejecuta esa configuración una vez por repositorio para configurar tu gestor de incidencias y tus convenciones. - Q: ¿Me atan a un proceso concreto? A: No. Están diseñadas para ser pequeñas, adaptables y componibles, y funcionan con cualquier modelo, por lo que mantienes el control en lugar de entregar todo el proceso a un framework. - **Awesome GEO** by luka2chat: Una lista curada de recursos sobre Generative Engine Optimization (GEO), la optimización de contenido para motores de respuesta con IA como ChatGPT, Perplexity, Claude y Google AI Overviews, que abarca artículos de investigación, herramientas, estrategias y casos de estudio. - Analog: https://analoghq.ai/es/luka2chat/skills/awesome-geo - Source: https://github.com/luka2chat/awesome-geo - Repo: https://github.com/luka2chat/awesome-geo - Tags: geo, aeo, ai-search, seo, open-source, curated-list, llm-seo, content-optimization - Pricing: free - Features: Lista curada de recursos sobre Generative Engine Optimization (GEO); Secciones dedicadas a investigación, guías, herramientas, estrategias y casos de estudio; Artículos de investigación fundacionales sobre GEO con resúmenes; Catálogo de docenas de herramientas de monitoreo y optimización para búsqueda con IA; Lista de verificación práctica de GEO para su implementación; Bilingüe (inglés y chino), con licencia CC0 y mantenida por la comunidad - Best for: Aprender sobre Generative Engine Optimization (GEO); Encontrar herramientas, investigación y casos de estudio sobre GEO; Profesionales del marketing y desarrolladores que optimizan para motores de respuesta con IA - Outcomes: Un mapa curado de investigación y herramientas de GEO; Estrategias prácticas y una lista de verificación de GEO; Opciones de proveedores para comparar - Caveats: Es una lista de enlaces, no instrucción original; Mantenida por la comunidad; la calidad de las herramientas listadas varía - Cost note: Gratuita (CC0); enlaza tanto a herramientas gratuitas como de pago. - Q: ¿Qué es Generative Engine Optimization? A: GEO es la optimización de contenido para que aparezca de forma destacada en motores de respuesta basados en IA como ChatGPT, Perplexity, Claude y Google AI Overviews, en lugar de hacerlo solo en los resultados de búsqueda tradicionales. - Q: ¿Qué incluye esta lista? A: Artículos de investigación, guías prácticas, videotutoriales, podcasts, herramientas de monitoreo y optimización de contenido, motores de búsqueda con IA, estrategias, casos de estudio, comunidades, libros y una lista de verificación de GEO. - Q: ¿A quién está dirigida? A: A profesionales del marketing y desarrolladores que desean aprender o implementar GEO y buscan un punto de partida curado sobre el tema, que incluya tanto investigación académica como herramientas prácticas. - **Hallmark** by nutlope: Una habilidad de diseño para Claude Code, Cursor y Codex que se niega a parecer generada por IA: elige una macroestructura para el encargo, aplica uno de veinte temas y ejecuta decenas de filtros anti-repetición antes de emitir el resultado. - Analog: https://analoghq.ai/es/nutlope/skills/hallmark - Source: https://www.usehallmark.com/ - Install: `npx hallmark` - Repo: https://github.com/Nutlope/hallmark - Tags: design, ui, anti-slop, skill, open-source, mit, claude-code, cursor - Pricing: free - Features: Habilidad de diseño que evita resultados genéricos con apariencia de IA; Elige una macroestructura y uno de veinte temas por encargo; Ejecuta 57 filtros anti-repetición más una autocrítica previa a la emisión; La rama Custom diseña paleta, tipografía y maquetación desde cero; Cuatro verbos: build, audit, redesign y study; study extrae el ADN de diseño de una captura de pantalla o URL; Se instala en Claude Code, Cursor y Codex - Best for: Diseñar UI que no parezca generada por IA; Auditar o rediseñar páginas existentes con mayor cuidado artesanal; Extraer el ADN de diseño de una referencia que admiras - Outcomes: Diseños distintivos adaptados al encargo, en lugar de plantillados; Un filtro anti-repetición antes de que el resultado salga; Entrega portátil de design.md a otras herramientas - Caveats: Genera diseños en HTML/CSS, no componentes de framework; study rechaza píxel-clones y plantillas de pago - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué hace Hallmark? A: Es una habilidad de diseño que construye UI evitando los valores por defecto genéricos de la IA: elige una macroestructura y un tema, y luego hace pasar el resultado por 57 filtros anti-repetición y una autocrítica antes de entregarlo. - Q: ¿Cuáles son sus cuatro verbos? A: El predeterminado construye nueva UI; audit puntúa el código existente contra los anti-patrones; redesign mantiene el texto, la IA y la marca, pero reconstruye con una nueva huella; y study extrae el ADN de diseño de una captura de pantalla o URL. - Q: ¿Cómo lo instalo? A: Ejecuta `npx skills add nutlope/hallmark`, o copia SKILL.md y sus referencias en Claude Code, Cursor o Codex. - **Superpowers** by obra: Un framework de habilidades agénticas y metodología de desarrollo de software para agentes de codificación, con habilidades componibles más instrucciones que impulsan un flujo de trabajo spec-first, TDD y basado en subagentes para Claude Code, Codex, Cursor, Gemini y más. - Analog: https://analoghq.ai/es/obra/skills/superpowers - Source: https://github.com/obra/superpowers - Install: `npm i superpowers` - Repo: https://github.com/obra/superpowers - Tags: open-source, agent, tdd, workflow, multi-harness, subagent, mit - Pricing: free - Features: Metodología de desarrollo de agentes completa construida sobre habilidades componibles; Las habilidades se activan automáticamente en cuanto el agente comienza a construir; De lluvia de ideas a especificación, planificación en tareas pequeñas y ejecución; Desarrollo basado en subagentes con revisión en dos etapas; TDD estricto de rojo-verde-refactorización y habilidades de depuración sistemática; Se instala en Claude Code, Codex, Cursor, Gemini y muchos más; Licencia MIT con telemetría opcional y desactivable - Best for: Proporcionar a los agentes una metodología de desarrollo completa y con criterio propio; Flujos de trabajo spec-first, TDD y basados en subagentes; Equipos con múltiples entornos (Claude Code, Codex, Cursor y más) - Outcomes: Lluvia de ideas hasta la especificación antes de escribir código; Planes verificables y en pasos pequeños; Ejecuciones de implementación autónomas y revisadas - Caveats: Flujos de trabajo obligatorios y con mucho proceso por diseño; Instalación separada por agente de codificación - Cost note: Gratuito y de código abierto (MIT). - Privacy note: La telemetría de versión anónima opcional está activada por defecto; desactivar mediante SUPERPOWERS_DISABLE_TELEMETRY. - Q: ¿Qué es Superpowers? A: Una metodología de desarrollo de software completa para agentes de codificación, entregada como habilidades componibles más instrucciones que hacen que el agente realice una lluvia de ideas para obtener una especificación, planifique en tareas pequeñas y ejecute una implementación basada en subagentes y con enfoque test-first. - Q: ¿Qué agentes admite? A: Muchos entornos, entre ellos Claude Code, Antigravity, Codex (app y CLI), Cursor, Factory Droid, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode y Pi, instalados por separado en cada entorno. - Q: ¿Necesito invocar las habilidades manualmente? A: No. Las habilidades se activan automáticamente como flujos de trabajo obligatorios; el agente comprueba si hay habilidades relevantes antes de cualquier tarea, por lo que no es necesario hacer nada especial. - **Claude Code Thinking Skills** by tjboudreaux: Una biblioteca de marcos de modelos mentales y pensamiento crítico empaquetados como habilidades de Claude Code: primeros principios, pensamiento sistémico, OODA, pre-mortem y más, invocados por nombre a través de un enrutador, con una pipeline de evaluación transparente. - Analog: https://analoghq.ai/es/tjboudreaux/skills/claude-code-thinking-skills - Source: https://github.com/tjboudreaux/cc-thinking-skills - Repo: https://github.com/tjboudreaux/cc-thinking-skills - Tags: claude-code, mental-models, critical-thinking, open-source, reasoning, agent, mit - Pricing: free - Features: Docenas de marcos de modelos mentales y pensamiento crítico como habilidades de Claude Code; El meta-skill thinking-model-router te dirige al marco adecuado; Marcos agrupados por toma de decisiones, sistemas, resolución de problemas y riesgo; Respaldados en marcos consolidados de ciencias cognitivas y estrategia; Pipeline de evaluación Elevate-or-Kill transparente y con replicación obligatoria; Publicación honesta de los resultados de evaluación; Instalación sin configuración a través del marketplace de plugins de Claude Code - Best for: Proporcionar a Claude Code marcos de razonamiento estructurado; Depuración, análisis de riesgo y decisiones estratégicas; Ingenieros, fundadores y analistas que buscan rigor - Outcomes: Modelos mentales bajo demanda (primeros principios, OODA y más); Un enrutador que selecciona el marco adecuado; Evaluación transparente y reportada honestamente - Caveats: Los autores reportan que ninguna habilidad tiene una ganancia de precisión robusta y replicada; Son andamiajes de razonamiento, no mejoras garantizadas - Cost note: Gratis y de código abierto (MIT). - Q: ¿Qué añade a Claude Code? A: Una biblioteca de habilidades de pensamiento con nombre (primeros principios, pre-mortem, bayesiano, pensamiento sistémico, OODA, teoría de restricciones y más) que proporcionan al agente marcos de razonamiento estructurado en lugar de heurísticas ad hoc. - Q: ¿Cómo elijo el adecuado? A: Comienza con el meta-skill thinking-model-router, que dirige tu problema al marco más apropiado; también puedes invocar cualquier habilidad directamente por nombre. - Q: ¿Hay evidencia de que las habilidades mejoran los resultados? A: El proyecto ejecutó cada habilidad a través de una evaluación con control de longitud y replicación obligatoria, e informa honestamente que ninguna habilidad cuenta aún con una ganancia de precisión robusta y replicada. Las habilidades son andamiajes de razonamiento útiles y la metodología se publica abiertamente. - **UI UX Pro Max** by nextlevelbuilder: Una habilidad de IA que proporciona a los agentes de codificación inteligencia de diseño, reglas de razonamiento y estilos de interfaz para generar UI/UX profesional en distintas plataformas y frameworks. - Analog: https://analoghq.ai/es/nextlevelbuilder/skills/ui-ux-pro-max - Source: https://www.uupm.cc/ - Repo: https://github.com/nextlevelbuilder/ui-ux-pro-max-skill - Tags: open-source, cli, design-system, claude-code, tailwind, ui, ux - Pricing: free - Features: Genera un sistema de diseño completo y personalizado a partir de una descripción del proyecto.; Recomienda patrón, estilo, paleta, tipografía y efectos clave.; Señala antipatrones del sector e incluye una lista de verificación previa a la entrega.; Biblioteca de reglas de razonamiento específicas del sector y estilos de interfaz.; Se instala como habilidad para Claude Code, Cursor, Copilot y Windsurf.; Herramienta de línea de comandos complementaria uipro-cli. - Best for: Arrancar un sistema de diseño a partir de la descripción de un proyecto.; Proporcionar a un agente de codificación orientación de UI/UX con criterio propio.; Evitar el estilo genérico predeterminado de la IA. - Outcomes: Un patrón, paleta, tipografía y efectos personalizados por descripción de proyecto.; Antipatrones del sector señalados desde el principio.; Una lista de verificación de calidad previa a la entrega. - Caveats: Son directrices y reglas de razonamiento, no una biblioteca de componentes.; El resultado aún requiere revisión humana de diseño. - Cost note: Gratuito y de código abierto (MIT); se aceptan donaciones. - Q: ¿Qué produce UI UX Pro Max? A: Un sistema de diseño completo para tu descripción: un patrón de maquetación, un estilo visual, una paleta de colores, una combinación tipográfica, efectos recomendados, una lista de antipatrones a evitar y una lista de verificación de calidad previa a la entrega. - Q: ¿Cómo elige un diseño? A: Ejecuta varias búsquedas paralelas sobre su biblioteca de reglas (con coincidencia por tipo de producto, estilo, paleta, patrón de landing page y tipografía), luego aplica reglas de razonamiento clasificadas y filtros de antipatrones del sector para ensamblar la recomendación. - Q: ¿Para qué herramientas está pensado? A: Se instala como habilidad de IA para agentes de codificación como Claude Code, Cursor, Copilot y Windsurf, y también incluye el comando uipro-cli. - **Agent Scripts** by steipete: Instrucciones de agente compartidas, habilidades de flujo de trabajo reutilizables y scripts auxiliares con pocas dependencias de Peter Steinberger para agentes de codificación estilo Codex y Claude. - Analog: https://analoghq.ai/es/steipete/skills/agent-scripts - Source: https://github.com/steipete/agent-scripts - Repo: https://github.com/steipete/agent-scripts - Tags: open-source, agent, cli, claude, codex, workflow, self-hosted - Pricing: free - Features: Habilidades de flujo de trabajo de agente reutilizables conectadas a Claude y Codex mediante symlinks; Front matter de `SKILL.md` optimizado para enrutamiento, no para documentación; Reglas estrictas compartidas en un único `AGENTS.MD` con inclusiones estilo puntero; Helper `committer` que valida las habilidades antes de hacer commit; Verificador `validate-skills` para el front matter de `SKILL.md`; Helper independiente de Chrome DevTools para automatización de navegador; Scripts portátiles con pocas dependencias, diseñados para compartirse entre repositorios - Best for: Compartir un mismo conjunto de reglas y habilidades de agente entre repositorios; Usuarios de Codex o Claude que quieren scripts auxiliares portátiles; Mantener las habilidades canónicas y enlazadas simbólicamente, sin copiarlas - Outcomes: Comportamiento consistente del agente en todos tus proyectos; Helpers reutilizables con pocas dependencias; Validación de habilidades aplicada antes de los commits - Caveats: Es una configuración de espacio de trabajo personal, no un framework pulido; Depende de convenciones de symlinks para el descubrimiento - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es Agent Scripts? A: Una colección canónica de instrucciones de agente compartidas, habilidades de flujo de trabajo reutilizables y scripts auxiliares con pocas dependencias para agentes de codificación estilo Codex y Claude. - Q: ¿Cómo se descubren las habilidades? A: El directorio de habilidades se enlaza simbólicamente en `~/.claude/skills` y `~/.codex/skills`, de modo que los agentes las detectan globalmente; cada habilidad es un `SKILL.md` con front matter YAML orientado al enrutamiento. - Q: ¿Qué helpers están incluidos? A: Un committer que valida las habilidades antes de hacer commit, un verificador de front matter `validate-skills`, un walker de listas de documentos y un helper independiente de Chrome DevTools para la automatización del navegador. - **Improve** by shadcn: Una habilidad de agente que audita cualquier base de código con tu modelo más capaz y escribe planes de implementación autocontenidos para que los ejecuten modelos más económicos (o humanos). - Analog: https://analoghq.ai/es/shadcn/skills/improve - Source: https://github.com/shadcn/improve - Install: `npx skills add shadcn/improve` - Repo: https://github.com/shadcn/improve - Tags: agent, open-source, cli, code-review, planning, multi-agent, mit-license, agentic - Pricing: free - Features: Audita una base de código y escribe planes ejecutables sin tocar el código fuente; Subagentes paralelos en nueve categorías con evidencia de file:line; Pasada de autoverificación que vuelve a leer las ubicaciones citadas para eliminar falsos positivos; Tabla de hallazgos ordenada por apalancamiento para que elijas; Planes autocontenidos con puertas de verificación y condiciones STOP; execute despacha un modelo más económico en un worktree aislado y lo revisa; Publicación opcional de planes como issues de GitHub - Best for: Auditar una base de código desconocida o legacy; Convertir hallazgos en especificaciones para que las construyan modelos más económicos; Revisión previa a un PR acotada a una rama - Outcomes: Tabla de hallazgos priorizada y respaldada por evidencia; Planes autocontenidos que cualquier agente o humano puede ejecutar; Menor gasto al reservar el modelo costoso para la planificación - Caveats: Nunca implementa código por sí misma; la ejecución se delega; La calidad del plan depende del modelo con el que lo ejecutes - Cost note: Gratuito y de código abierto (MIT); solo pagas por los modelos que utiliza. - Privacy note: Lee y analiza el código localmente a través de tu propio agente; reporta ubicaciones y tipos de credenciales, nunca los valores secretos. - Q: ¿En qué se diferencia Improve de un agente de programación? A: Deliberadamente nunca implementa nada. Usa un modelo costoso para entender el repositorio y escribir planes rigurosos, luego delega la ejecución a modelos más económicos o a humanos, y la decisión de hacer merge siempre es tuya. - Q: ¿Qué contiene un plan? A: Cada plan es autocontenido: rutas de archivo exactas, fragmentos del código en su estado actual, los propios comandos de test y lint del repositorio como puertas de verificación, una lista de elementos fuera de alcance y condiciones STOP para cuando la realidad no coincida con el plan. - Q: ¿Qué agentes pueden ejecutarlo? A: Cualquier agente que soporte el formato Agent Skills. Instálalo con npx skills add shadcn/improve. --- ## Plugins Plugins and extensions bolt new powers onto the AI coding tools you already run — from editor add-ons to Claude Code plugins that bundle slash commands, subagents, hooks, and MCP servers into one installable package. They're the fastest way to reshape an agent's behavior without rebuilding your setup. Browse the community's top picks, ranked by real usage. “Plugin” covers a few related things in the AI-coding world: extensions for editors and agentic IDEs, integrations that connect a tool to the rest of your stack, and — in Claude Code specifically — installable bundles that can ship commands, subagents, hooks, and MCP servers together from a single marketplace entry. What they share is that they extend a tool you already use rather than replacing it. The right plugin removes friction you'd otherwise hit every day: a one-command install for a workflow you keep rebuilding, an integration that wires your agent into CI or a tracker, or an editor extension that adds a missing capability. Because plugins change what your tools can do, prefer open-source ones you can read, and check each entry's link for supported versions and setup before installing. ### FAQ: Plugins **What counts as a plugin here?** Any extension, add-on, integration, or installable bundle that augments an existing AI coding tool — editor extensions, agent integrations, and Claude Code plugins that package commands, subagents, hooks, or MCP servers. **What's the difference between a plugin and a skill?** A skill teaches an agent how to do a task through instructions. A plugin extends the tool itself — adding commands, integrations, or whole feature bundles. A single plugin can even ship skills, MCP servers, and hooks together. **How do I install a plugin?** It depends on the host tool: editor plugins install from the editor's marketplace, while Claude Code plugins install from a plugin marketplace by name. Open an entry and follow its link for the exact command or steps. **Are these plugins safe to install?** Plugins can run code and access your tools, so install ones you trust. Favor open-source plugins you can inspect, check the repository's activity and issues, and review what permissions or hooks a plugin sets up before enabling it. **Are the plugins free?** Many are open source; some are commercial. Open an entry and follow its link for pricing and licensing. **How are plugins ranked on Analog?** By community upvotes, one per account, with new releases under the New tab. Every plugin is human-reviewed before it's listed. ### Entries in Plugins (ranked) - **Cursor Plugins** by cursor: La especificación oficial de plugins de Cursor más un marketplace de plugins de primera parte, integraciones independientes para herramientas de desarrollo, frameworks y productos SaaS, cada uno con su propio manifiesto. - Analog: https://analoghq.ai/es/cursor/plugins/cursor-plugins - Source: https://github.com/cursor/plugins - Repo: https://github.com/cursor/plugins - Tags: open-source, cursor, mcp, agent, cli, developer-tools, mit - Pricing: free - Features: Especificación oficial de plugins de Cursor y formato de manifiesto; Marketplace de plugins de primera parte, cada uno con su propio manifiesto; Los plugins pueden agrupar habilidades de agente, reglas de Cursor y servidores MCP; Incluye los plugins Thermos de revisión de seguridad, Orchestrate y Canvas; Patrones de integración del Cursor SDK para construir automatizaciones; Create Plugin genera la estructura y valida nuevos plugins - Best for: Extender Cursor con flujos de trabajo oficiales de primera parte; Aprender el formato de manifiesto de plugins de Cursor; Equipos que estandarizan revisión y orquestación en Cursor - Outcomes: Plugins listos para usar de revisión, memoria, orquestación y documentación; Una referencia para crear tus propios plugins; Habilidades, reglas y servidores MCP agrupados por plugin - Caveats: Específico de Cursor, no portable a otros editores; Los plugins individuales varían en alcance y madurez - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es un plugin de Cursor? A: Un paquete independiente con un manifiesto .cursor-plugin/plugin.json que puede agrupar habilidades de agente, reglas de Cursor y definiciones de servidor MCP para extender Cursor en una herramienta, framework o flujo de trabajo específico. - Q: ¿Qué plugins están incluidos? A: Plugins de primera parte como Continual Learning, Cursor Team Kit, revisión de ramas con Thermos, PR Review Canvas, Docs Canvas, Cursor SDK, Orchestrate y Create Plugin. - Q: ¿Puedo crear el mío propio? A: Sí. El repositorio funciona también como referencia para el formato de plugins, y el plugin Create Plugin genera y valida un nuevo plugin por ti. --- ## MCP Servers Model Context Protocol (MCP) servers connect AI agents to external tools, APIs, and data sources through a single open standard, so you wire up a capability once and any MCP-compatible client can use it. Introduced by Anthropic in late 2024 and now supported across the major agent tools, MCP is becoming the USB-C of AI integrations. This is the index of the most useful MCP servers for building with agents — official and community alike. MCP is an open protocol built on JSON-RPC. An MCP server exposes three kinds of capability to a client: tools (actions the model can call, like querying a database or opening a PR), resources (read-only context such as files or records), and prompts (reusable templates). Clients connect over a local transport (stdio) or a remote one (Server-Sent Events or streamable HTTP), which means a server can run on your machine or as a hosted service. The payoff is portability: the same server that gives Claude access to your Postgres database also works in Cursor, VS Code, Windsurf, Zed, and other MCP clients, with no bespoke integration per tool. Because servers can read data and take actions, run ones you trust, prefer official or open-source implementations, and use OAuth or scoped credentials where a server supports it. Each entry below links to its repository with supported clients and exact setup. ### FAQ: MCP Servers **What is an MCP server?** Model Context Protocol (MCP) is an open standard for connecting AI agents to tools and data. An MCP server exposes a capability — a database, an API, a filesystem — that any MCP-compatible client can discover and call through one common protocol. **How does MCP work?** MCP uses JSON-RPC between a client (the AI app) and a server (the capability). A server offers tools the model can invoke, resources it can read, and prompt templates, communicating over stdio for local servers or SSE/HTTP for remote ones. The client handles discovery and passes the model's requests to the server. **Which tools and clients support MCP?** Claude (desktop, Code, and the API), Cursor, VS Code, Windsurf, Zed, and a growing list of agentic clients support MCP. Check each server's link for the clients it has been tested with. **How do I add an MCP server?** You register the server in your client's MCP configuration — typically its name, command or URL, and any credentials — then restart or reload the client so it picks up the new tools. Each entry links to its repository with exact configuration. **What's the difference between an MCP server and a plugin or API?** An API is the raw interface a service exposes; an MCP server wraps a capability in the MCP standard so any agent can use it without custom code. A plugin is usually tool-specific, while an MCP server is portable across every MCP client. **Is MCP secure?** MCP servers can read data and take actions, so treat them like any dependency: run servers you trust, prefer official or open-source ones you can inspect, scope credentials narrowly, and use OAuth where the server supports it. Review what tools a server exposes before connecting it. **What's the difference between official and community MCP servers?** Official servers are published by the company behind the service (for example, a vendor's own database server); community servers are built by third parties. Both can be excellent — Analog curates for quality and labels the source on each entry. ### Entries in MCP Servers (ranked) - **Executor** by rhyssullivan: MCP gateway that gives AI agents like Claude Code, Cursor, and Codex one endpoint and one tool shape for every integration, with sandboxed execution and credential isolation by design. - Analog: https://analoghq.ai/es/rhyssullivan/mcp-servers/executor - Source: https://executor.sh - Install: `npm install -g executor executor install executor web # MCP server executor mcp` - Repo: https://github.com/RhysSullivan/executor - Tags: mcp, open-source, cli, agent, self-hosted, typescript, gateway, integration - Pricing: freemium - Features: Unified MCP gateway: one endpoint for OpenAPI, GraphQL, MCP, and Google Discovery tools; Lazy schema loading: only the called tool's schema enters the prompt, not the full catalog; Isolated JavaScript sandbox: secrets injected host-side, never visible to agent or model; Semantic safety gates: auto-runs safe methods, pauses for destructive ones pending user approval; Per-user and shared credentials with team-wide policy enforcement; Web UI for adding sources, CLI for headless and server environments; Trace view (coming soon): full run and tool-call history for post-hoc audit; MIT-licensed desktop app and CLI; cloud tier with org-wide auth and SSO - Best for: Teams running multiple MCP-compatible agents against a shared company tool stack; Builders who want to eliminate per-agent integration wiring for tools like GitHub, Stripe, Jira, or Slack; Projects where token budget is tight and loading hundreds of tool schemas into context is not viable; Teams using OpenAPI, GraphQL, existing MCP servers, or Google Discovery as integration sources - Outcomes: A single MCP endpoint and one tool shape called execute replaces per-agent wiring for every connected source; Context overhead drops by up to 99.6%, from roughly 278,800 tokens across a large tool set to around 1,044 tokens; Credentials are resolved host-side and never enter the sandbox heap or model context, by architectural constraint not policy; Safety semantics like GET vs DELETE and destructiveHint are preserved and enforced uniformly across all calling surfaces; Lazy schema loading means only the matching tool schema is loaded at call time, not the full catalog - Caveats: Project is active but relatively early, at v1.5.19 as of June 2026, with 93 releases and 2,349 GitHub stars; Free tier is capped at 3 members and 10,000 executions per month, with overages billed at $0.20 per 1,000 executions; Audit logs are Enterprise-only today; free and team tiers list them as coming soon; Any source must be representable as a JSON schema to qualify as an integration; Primarily TypeScript at 96.7%, which may matter if you need to fork or extend the runtime - Q: What is Executor? A: Executor is an MCP gateway that gives AI agents a single endpoint and a single tool shape for every integration they need. Any MCP-compatible agent, including Claude Code, Cursor, and Codex, points at one Executor endpoint and can reach tools sourced from OpenAPI specs, GraphQL schemas, existing MCP servers, and Google Discovery documents. The project is MIT licensed, available as a cloud service, a native desktop app, and an npm CLI. - Q: How do I install and connect Executor to my agent? A: Install the CLI with `npm install -g executor`, then run `executor install` to set up the local background service and `executor web` to open the web UI where you add sources. To use it as an MCP server, run `executor mcp` and add an entry to your agent's `mcp.json` pointing the command at `executor` with the arg `mcp`. The README includes a ready-to-paste config block for Claude Code and Cursor. - Q: Is Executor free or open source? A: The desktop app and CLI are MIT licensed with source available on GitHub. The cloud service has a free tier supporting up to 3 members and 10,000 executions per month. The Team plan is $150 per org per month for unlimited members and 250,000 included executions, with overage at $0.20 per 1,000 additional executions. Enterprise pricing is custom and includes self-hosted or dedicated cloud deployment support and SSO. - Q: What is Executor best for? A: Executor is best for teams running multiple AI agents against a large shared catalog of company tools, where context bloat and per-client credential wiring are real problems. The executor.sh site documents the core case directly: connecting eight common services (GitHub, Stripe, Jira, Sentry, Linear, Gmail, Notion, Slack) gives an agent 1,640 tools at roughly 278,800 tokens without Executor, versus 1 tool at roughly 1,044 tokens with it. It is also a strong fit for orgs that need consistent safety gates across all agent surfaces without rebuilding policies per client. - Q: How does Executor handle credentials and secrets? A: Executor resolves credentials host-side at call time and injects them only into the outbound HTTP request. They never enter the sandboxed JavaScript runtime where agent-written code runs, and they are never present in anything the model can read. The MCP documentation describes this as a structural constraint of the architecture, not a configurable policy. On the desktop and CLI deployments, integrations and sessions stay entirely on-device. - Q: What are Executor's current limitations? A: Call tracing (a single view of every run and tool call for post-hoc audit) is listed as coming soon and is not yet generally available. Audit logs are only available on the Enterprise tier. The cloud free tier caps at 3 members and 10,000 executions per month, which may be tight for larger teams before committing to the $150/month Team plan. Pi, the AI agent, does not have a native MCP client and requires a separate community-maintained bridge package to work with Executor. - **Headroom** by headroomlabs-ai: Context compression MCP server and proxy for AI agents, cuts token usage 60-95% across tool outputs, logs, RAG, and files while preserving answer accuracy. - Analog: https://analoghq.ai/es/headroomlabs-ai/mcp-servers/headroom - Source: https://headroomlabs-ai.github.io/headroom/ - Install: `pip install "headroom-ai[all]" npm install headroom-ai headroom proxy --port 8787 headroom wrap claude headroom perf` - Repo: https://github.com/headroomlabs-ai/headroom - Tags: open-source, mcp, proxy, compression, agent, python, typescript, local-first - Pricing: free - Features: Three MCP tools: headroom_compress, headroom_retrieve, headroom_stats; Transparent proxy mode, zero code changes, any language or framework; Six content-type-aware compressors: JSON, AST/code, prose (ML), logs, search results, git diffs; CCR reversible compression: originals stored locally, retrievable by hash; CacheAligner: stabilizes message prefixes for provider KV cache hit optimization; Cross-agent shared context store with auto-dedup across Claude, Codex, Gemini; Output token shaper: verbosity steering and effort routing to trim model replies; Prometheus metrics, cost tracking, budget limits, and live savings dashboard - Best for: Agentic workflows drowning in tool call outputs, logs, RAG results, and conversation history that inflate token costs; Teams wanting zero-code-change compression via a transparent proxy in front of any LLM provider; Builders using Claude who want KV cache hits to actually materialize via stable prefix alignment; SRE or DevOps agents processing large log dumps, incident traces, or GitHub issue backlogs - Outcomes: 60 to 95% token reduction on real agent workloads with no loss of original content, retrievable by hash on demand; Flat or improved benchmark accuracy: GSM8K delta zero, TruthfulQA up 0.030, BFCL tool-calling at 97% with 32% compression; KV cache hit rates improve on Claude via CacheAligner stabilizing message prefixes before they reach the provider; Session-level cost and savings tracking exposed via the headroom_stats MCP tool; Drop-in proxy mode requires only an env var change, no agent code modifications needed - Caveats: Output-token shaping reports estimated savings by default; measured savings require opting into a 10% holdout via HEADROOM_OUTPUT_HOLDOUT=0.1; ML compression via Kompress adds a non-trivial dependency footprint through the [ml] extra and requires PyTorch; Compressed originals are stored locally with a 1-hour TTL, so retrieval windows are time-bounded; Benchmark numbers are from the project README and reproducible via the built-in eval suite, but reflect controlled conditions - Cost note: ="Licensed Apache 2.0 and free for commercial use. Savings are on downstream LLM token costs, not Headroom licensing fees." - Q: What is Headroom and what problem does it solve? A: Headroom is a context compression layer for AI agents and LLM applications that reduces token consumption by 60-95% on tool outputs, logs, RAG results, files, and conversation history before the content reaches the model. Every agent tool call, database read, or retrieval result tends to be 70-95% boilerplate the model does not need; Headroom compresses that noise away using six specialized algorithms. Critically, it is reversible: originals are stored locally in a CCR store and the LLM can retrieve them on demand via a hash key, so no information is permanently discarded. - Q: How do I install and start using Headroom? A: Install with `pip install "headroom-ai[all]"` (Python 3.10+ required) or `npm install headroom-ai` for TypeScript. For the MCP server specifically, run `pip install "headroom-ai[proxy]"` or the lighter `pip install "headroom-ai[mcp]"`, then `headroom mcp install` to register with Claude Code, and finally `claude` to start a session with compression tools available. For zero-code-change proxy mode, run `headroom proxy` and point your app at `http://localhost:8787`. To wrap a coding agent in one step, use `headroom wrap claude` (or `codex`, `aider`, `copilot`, `opencode`). - Q: Is Headroom free? What is the license? A: Headroom is open source under the Apache 2.0 license, which permits free commercial use. There are no usage fees from Headroom itself; you continue to pay your LLM provider for the tokens consumed, which Headroom reduces significantly. The library, proxy, and MCP server are all included in the open-source distribution. - Q: What kinds of workloads benefit most from Headroom? A: Headroom delivers the largest savings on tool-heavy agentic workflows where individual tool calls return large JSON blobs, log dumps, grep results, or RAG retrievals. Per the README benchmarks, code search over 100 results compresses 92%, SRE incident debugging compresses 92%, and GitHub issue triage compresses 73%. It also helps multi-agent systems by providing a shared, deduplicated context store across Claude, Codex, and Gemini instances. Workloads with short, focused prompts that already fit comfortably in context will see less benefit. - Q: How does Headroom compare to just summarizing or truncating context manually? A: Unlike manual summarization or naive truncation, Headroom uses content-type-aware compressors that preserve semantically important content: SmartCrusher keeps statistical anomalies and boundary values in JSON, CodeCompressor (via tree-sitter AST analysis) preserves function signatures while collapsing bodies, and LogCompressor retains errors and warnings while dropping passing noise. Crucially, it is reversible via CCR: a hash-addressed local store lets the LLM retrieve full originals when it needs them, which no truncation approach supports. Accuracy benchmarks at N=100 show GSM8K math scores hold flat and BFCL tool-calling accuracy stays at 97% with 32% compression. - Q: What are the main limitations or risks to know about? A: ML-based text compression (Kompress) requires PyTorch, adding substantial install weight, use `pip install "headroom-ai[ml]"` only when prose compression is needed. Output token shaping is off by default, and savings estimates are counterfactual: Headroom reports a 95% confidence interval rather than an exact number, unless you opt into a holdout control group via `HEADROOM_OUTPUT_HOLDOUT=0.1`. Compressed originals in the local CCR store have a 1-hour TTL, so long-running sessions that pause and resume may lose retrieval access to early content. Cursor integration is manual; users must paste proxy base URLs into Cursor's settings rather than using an automated wrap command. --- ## IDEs Agénticos Agentic IDEs are AI-native editors built around autonomous coding agents — they read your codebase, plan a change, edit across many files, run commands and tests, and iterate on the results alongside you. They go beyond autocomplete to complete whole tasks. Compare the leading options — Cursor, Claude Code, Windsurf, Cline, and more — ranked by the developers who ship with them daily. What separates an agentic IDE from ordinary AI autocomplete is the loop: the agent forms a plan, makes multi-file edits, runs the project (build, tests, linters), reads the output, and corrects itself — repeating until the task is done or it hands back to you. Most expose controls for how much autonomy you grant, from suggest-and-approve to fully hands-off runs, plus context features like codebase indexing and rules files. They come in different shapes: full editors (Cursor, Windsurf), terminal-native agents (Claude Code), editor extensions (Cline and others), and cloud agents that work from an issue or a branch. The best choice depends on your stack, how much control you want, and whether you prefer a local or cloud workflow. Open each entry to compare strengths, pricing, and the models it runs. ### FAQ: IDEs Agénticos **What makes an IDE “agentic”?** An agentic IDE runs an autonomous agent that can read your codebase, plan changes, edit multiple files, and run commands — then check the results and iterate. It completes whole tasks rather than just suggesting the next line of code. **How is an agentic IDE different from AI autocomplete?** Autocomplete predicts the next few lines as you type. An agentic IDE takes a goal, makes changes across the project, runs tests, and fixes what it broke — operating in a plan-act-observe loop instead of a single suggestion. **Which agentic IDE should I choose?** It depends on your stack and how much autonomy you want. Prefer a familiar editor experience and you'll lean toward Cursor or Windsurf; prefer the terminal and you'll reach for Claude Code; want a free, open-source extension and Cline is worth a look. Browse the ranked list and open each entry to compare. **Do agentic IDEs work with my language and framework?** Most are language-agnostic because they drive the same tools you do — your compiler, test runner, and shell. Coverage and quality vary by ecosystem, so check each entry for noted strengths. **Are agentic IDEs free?** Some are free or open source (for example, Cline); others are paid or usage-based, often billing for model tokens. Open an entry for current pricing. **Are agentic IDEs safe to let run commands?** They can run shell commands and edit files, so most offer approval modes and sandboxing. Start with approve-before-run on unfamiliar projects, work in version control, and increase autonomy as you build trust. --- ## Software & Tools Standalone AI software and tools that go beyond the code editor — the apps, platforms, and services worth adding to your stack. From observability and evals to data, search, and deployment, these are the tools that slot in around your agents. Browse the community's picks, ranked by real use. Not everything useful lives inside your editor. This topic covers standalone AI software: platforms for tracing and evaluating model output, vector and data tools, agent-orchestration frameworks, and the services you connect to your build. They're the supporting cast that turns a clever prototype into something you can run and trust in production. Some are open source and self-hostable; others are commercial SaaS with free tiers. The right pick depends on where the gap in your stack is — instrumentation, retrieval, deployment — and how much you want to operate yourself. Open each entry for pricing, hosting options, and how it fits alongside the tools you already run. ### FAQ: Software & Tools **What belongs in Software & Tools?** Any standalone AI software or service that isn't an editor, plugin, or MCP server — apps, platforms, frameworks, and utilities that support building and running AI: observability, evals, data and search, orchestration, and deployment. **How is this different from Plugins?** Plugins extend a tool you already run from inside it; software and tools stand on their own and you connect to them. A plugin lives in your editor; a tool here is its own app or service. **Are these tools open source or paid?** Both. Some are open source and self-hostable, others are commercial SaaS, and many offer a free tier. Open an entry for licensing, hosting options, and pricing. **How are tools ranked on Analog?** By community upvotes, one per account, with new additions under the New tab. Every tool is human-reviewed before it's listed. ### Entries in Software & Tools (ranked) - **Maple** by makisuo: Open-source OpenTelemetry observability platform with traces, logs, metrics, service maps, session replay, and an AI agent MCP server, for backend and platform teams. - Analog: https://analoghq.ai/es/makisuo/software-tools/maple - Source: https://maple.dev - Install: `bun install # Local bundle path from README brew install Makisuo/tap/maple maple start` - Repo: https://github.com/Makisuo/maple - Tags: observability, open-source, opentelemetry, self-hosted, mcp, agent, kubernetes, clickhouse - Pricing: freemium - Features: OpenTelemetry-native OTLP ingest with no proprietary agent; Distributed trace waterfall with span attribute inspection; Structured log streaming with severity, service, and regex search; Real-time service map showing request rates, error rates, and latency per edge; Browser session replay linked to backend trace IDs via shared session ID; Kubernetes monitoring via Helm chart with pod, node, and kube-state metrics; First-class MCP server for AI agent access to telemetry, error diagnosis, and PR creation; Alerting worker and mobile app included in the monorepo - Best for: Teams wanting unified traces, logs, metrics, service maps, and Kubernetes monitoring in a single OTel-native tool; Builders who want AI agents to query and act on telemetry via a first-class MCP server; Cost-conscious teams frustrated by per-host and per-seat observability pricing models; Self-hosters who want a single binary install via Homebrew with embedded ClickHouse and dashboard bundled - Outcomes: A unified observability backend covering traces, logs, metrics, service maps, trace waterfalls, and Kubernetes pod heatmaps; ClickHouse-backed storage and query performance surfaced through a live TanStack Router frontend; An MCP server exposing list_services, find_errors, error_detail, and propose_fix for AI agent integration; A single maple start command that bundles OTLP ingest, embedded ClickHouse, and the dashboard locally; Browser session replay and structured log streams alongside infrastructure monitoring in one tool - Caveats: FSL-1.1 is not OSI-approved and restricts competitive use until the code converts to Apache 2.0, with no public conversion date; Teams should review FSL license terms before adopting if open-source compliance is a procurement requirement; Cloud dashboard persistence requires Turso, while local mode relies on SQLite, so deployment model affects persistence choice; MCP agent capabilities are demonstrated in a site demo context, real-world tool call performance may vary by environment - Cost note: Maple charges per GB ingested with no per-host or per-seat fees, inverting the compounding cost model common to modern observability platforms. Source is available under FSL-1.1 on GitHub and can be self-hosted. - Privacy note: Self-hosted deployment via the local binary keeps telemetry data on your own infrastructure. Cloud mode uses Turso for dashboard persistence; teams should review Turso data handling terms for sensitive workloads. - Q: What is Maple? A: Maple is an open-source observability platform for distributed systems that collects and queries traces, logs, and metrics over OpenTelemetry. It is backed by ClickHouse for fast analytical queries and ships with a service map, browser session replay, Kubernetes monitoring, and a first-class MCP server for AI agents. The source is available on GitHub under the FSL-1.1 license, which converts to Apache 2.0 over time. It can be used as a hosted service or self-hosted on your own infrastructure. - Q: How do I install and run Maple locally? A: The fastest path is the local binary: run `brew install Makisuo/tap/maple` then `maple start`, which spins up OTLP ingest, embedded ClickHouse, and the dashboard as a single process. For a full development stack, clone the monorepo, run `bun install` (Bun >= 1.3 required), then `bun run dev` to start all apps together. A Docker Compose file is also provided for a multi-service local stack with the API on port 3472, the web UI on 3471, and the OTLP collector on ports 4317 (gRPC) and 4318 (HTTP). - Q: Is Maple free or open source? A: Maple's source code is publicly available on GitHub under the Functional Source License (FSL-1.1), which grants broad rights to read, fork, and self-host while restricting certain competitive uses. Per the site FAQ, the license converts to Apache 2.0 over time. The hosted version starts with a free trial; paid plans are billed at a flat $0.30/GB ingested with no per-host or per-seat fees. - Q: What is Maple best suited for? A: Maple is best for backend and platform teams already using OpenTelemetry who want a single backend for traces, logs, and metrics without vendor lock-in or compounding per-host fees. It particularly shines when you need AI agents to interact with live telemetry over MCP, the built-in MCP server lets an agent list services, search for errors, inspect root causes, and open pull requests autonomously. Kubernetes teams benefit from the Helm chart that joins pod and node metrics directly to spans. - Q: How does Maple compare to Datadog, New Relic, and Grafana Cloud? A: Maple's published pricing table shows Datadog charges $15+/host/month plus $1.27/M events with no self-host option and only partial OTel support, while New Relic charges $99/full-user/month on top of ingest fees. Grafana Cloud is closer in OTel support but uses AGPL components and has no first-class MCP/agent surface. Maple's main advantages per the sources are: no per-host or per-seat fees, native OTel (no proprietary agent), a self-host path, and the MCP server for AI agent access. The FSL-1.1 license is Maple's main procurement caveat versus Grafana's AGPL. - Q: What are Maple's key limitations? A: FSL-1.1 is not an OSI-approved open-source license, which may block adoption under strict open-source procurement policies. The self-hosted mode removed multi-tenant JWT/API-key paths in a breaking change, and MAPLE_ROOT_PASSWORD is now required for self-hosted deployments. Private ingest keys are encrypted at rest with a customer-supplied key, so losing that key means losing access to the keys. The monorepo requires Bun >= 1.3, which may not fit all existing toolchains. - **cult/ui** by nolly-studio: 78+ animated shadcn/ui components plus 100+ AI agent patterns, distributed as copy-paste source, free, open-source, and zero npm lock-in. - Analog: https://analoghq.ai/es/nolly-studio/software-tools/cult-ui - Source: https://cult-ui.com - Repo: https://github.com/nolly-studio/cult-ui - Tags: open-source, react, tailwind, shadcn, components, ai-agents, next-js, mit-license - Pricing: freemium - Features: 78+ animated, accessible UI components for shadcn/ui projects; Source-code distribution via shadcn registry CLI, no npm package, full ownership; 100+ AI SDK agent patterns with live interactive previews; 4 full-stack Next.js agent templates (ecommerce, RAG platform, SaaS chat, sub-agent starter); Premium Cult Pro tier: 129 marketing blocks, 36 components, 10 starter templates; Supports Vercel AI SDK, OpenAI, Google Gemini, Firecrawl, Upstash, pgvector, Stripe; MIT license for the open-source component core; Compatible with v0 (open in v0 option for agent patterns) - Best for: React and Tailwind teams already using shadcn/ui who want animated, accessible components without npm package overhead; Builders who want full source ownership and no versioning lock-in on UI components; Teams shipping AI-powered apps on the Vercel AI SDK who need copy-paste agent patterns; Developers building a custom design system on top of shadcn/ui conventions - Outcomes: 78+ animated, accessible UI components copied directly into your codebase as owned, editable source code; 100+ copy-paste AI agent patterns for the Vercel AI SDK covering orchestrator, evaluator-optimizer, routing, and multi-step tool patterns; Four full-stack Next.js templates covering multi-tenant auth chat, RAG agent platform, ecommerce multi-agent, and a minimal sub-agent starter; A reference implementation for building your own design system on top of shadcn/ui - Caveats: The open-source MIT core covers 78+ components, but 129 marketing blocks, 36 additional components, and 10 starter templates require a paid Cult Pro tier; No monolithic npm package means updates are manual, each component you copy is yours to maintain going forward; Library has 4.5k GitHub stars and is actively expanding, but maturity varies across the newer AI agent pattern additions - Cost note: ">The open-source core is MIT-licensed and free. Cult Pro is a paid tier that gates 129 marketing blocks, 36 additional components, and 10 starter templates. Pricing details are not specified in the entry content. - Q: What is cult/ui? A: cult/ui is a free, open-source library of 78+ animated and accessible UI components that extend shadcn/ui projects. Unlike traditional component packages, it distributes components as source code via the shadcn registry CLI, meaning you copy only the components you need into your own codebase and fully own them. The library is licensed under the MIT license and built on React, Tailwind CSS, and shadcn/ui. - Q: How do I install or use cult/ui components? A: Per the docs, you add components through the shadcn registry CLI or copy the source directly into your project, there is no npm package to install. Because each component lives as first-class code in your repo, you can adapt, extend, or delete it freely. The documentation at cult-ui.com/docs covers the setup process and registry workflow. - Q: Is cult/ui free and open source? A: The core library of 78+ components is free and MIT-licensed. The repository notes that purchasing AI SDK Agents or Cult Pro directly supports maintaining and growing the open-source library. Cult Pro (129 premium marketing blocks, 36 additional components, and 10 starter templates) and the AI SDK Agents pattern library are paid companion products; the sources do not publish specific prices. - Q: What is cult/ui best for? A: cult/ui is best for React and Tailwind teams already using shadcn/ui who want animated, niche components without adding a versioned npm dependency they have to style around. It is also a strong fit for developers building AI-powered SaaS on Next.js and the Vercel AI SDK, thanks to 100+ copy-paste agent patterns covering orchestrator, RAG, multi-step tool, and multi-tenant chat use cases. - Q: How does cult/ui compare to installing a traditional component library? A: Traditional component libraries ship as npm packages with a dependency layer you style around and upgrade on the library's schedule. cult/ui, per its own docs, is 'not a traditional npm component package', components arrive as source code you own and modify directly. The tradeoff is that you manage updates yourself rather than bumping a package version, but you gain full design-system control with no black-box constraints. - Q: What are the main limitations or risks of using cult/ui? A: The biggest practical limitation is the manual update model: because there is no npm package, keeping components current with upstream changes requires manual effort. The library is React/Tailwind/shadcn only, no Vue, Svelte, or Angular support is mentioned in the sources. Additionally, the premium Cult Pro layer gates a large portion of the marketing and template content behind a paid plan, so teams who need production-ready landing page sections should budget for that. - **Mnemosyne** by axdsan: Zero-dependency, SQLite-backed AI memory layer for agents, MCP-ready, local-first, and benchmarked against BEAM and LongMemEval. - Analog: https://analoghq.ai/es/axdsan/software-tools/mnemosyne - Source: https://github.com/AxDSan/mnemosyne - Install: `pip install mnemosyne-memory pip install "mnemosyne-memory[all]" mnemosyne mcp` - Repo: https://github.com/AxDSan/mnemosyne - Tags: open-source, agent, memory, mcp, sqlite, local-first, python, self-hosted - Pricing: free - Features: Built-in MCP server (stdio and SSE transport modes); Python SDK with remember() and recall() as primary API; 3-tier BEAM architecture: working memory, episodic memory, TripleStore; Binary vector compression (MIB): 32x size reduction via Hamming distance in SQLite; Temporal knowledge graph with version chains via TripleStore; Per-domain memory banks for isolation across contexts; Bidirectional sync with optional XChaCha20-Poly1305 client-side encryption; CLI for direct memory ops, stats, export/import, and consolidation (sleep) - Best for: Builders who want persistent agent memory with zero infrastructure, no Postgres, Docker, or SaaS required; Teams deploying to constrained environments where a single SQLite file is the only practical store; Agents built on Hermes or any framework needing MCP-native memory via stdio or SSE; Projects that need local-first, no-telemetry memory with MIT licensing for compliance or privacy reasons; Rapid prototyping where one pip install must cover the entire memory stack - Outcomes: A fully local memory layer with sub-millisecond recall backed by SQLite, no external vector DB needed; 3-tier BEAM memory: TTL-based working memory, hybrid episodic search, and a temporal TripleStore; 98.9% Recall@All@5 on LongMemEval and 100% abstention accuracy on unknowns, per self-reported benchmarks; 32x embedding compression via binary MIB encoding, reducing 384-dim float32 vectors to 48 bytes; 9.4x storage savings through episodic compression with recall held flat from 100K to 10M tokens; A built-in MCP server plus a minimal Python SDK with remember() and recall() as the primary API surface - Caveats: All benchmarks are self-reported from the README, no independent third-party validation is cited; recall@10 is 20% flat across scales in the BEAM retrieval table, limiting how much context surfaces per query; Omitting the [all] install flag disables vector search, reducing retrieval quality in exchange for zero dependencies; No ANN index is used; Hamming distance runs directly inside SQLite, which may not scale to very large stores; MIB binary compression is a lossy approximation of full float32 embeddings and may affect edge-case recall - Q: What is Mnemosyne (AxDSan)? A: Mnemosyne is a zero-dependency AI memory layer that gives any agent persistent, searchable memory backed by a single SQLite file. It uses a 3-tier BEAM architecture (working memory, episodic memory, and a temporal TripleStore) to store and retrieve facts without requiring Postgres, Docker, or any external vector database. It ships with a built-in MCP server, a Python SDK, and integration guides for Cursor, Claude Code, Codex CLI, Windsurf, OpenWebUI, and OpenClaw. - Q: How do I install and start using Mnemosyne? A: Run `pip install mnemosyne-memory` for the base install, or `pip install "mnemosyne-memory[all]"` to include vector search and the full MCP server. For MCP-based tools like Cursor or Claude Code, add a one-line JSON block pointing to the `mnemosyne mcp` command in the platform's MCP config file. For Python agents, import `remember` and `recall` directly from the `mnemosyne` package and call them anywhere in your agent loop. - Q: Is Mnemosyne free and open source? A: Yes, Mnemosyne is released under the MIT license with no paid tiers mentioned in the sources. It is fully self-hostable and requires no cloud account or subscription. The optional sync server can be run on your own infrastructure (Docker, bare metal, or Fly.io). - Q: What is Mnemosyne best suited for? A: Mnemosyne is best for agent developers who need persistent cross-session memory without spinning up cloud infrastructure. It excels in local-first setups where all data must stay on-device, in MCP-native workflows (Cursor, Claude Code, Codex), and in scenarios where episodic compression and a temporal knowledge graph add real value. Per the README, it supports 8+ agent platforms out of the box. - Q: How does Mnemosyne compare to mem0, Honcho, or ChromaDB? A: Mnemosyne is the only option in the comparison table that is local-first, zero-dependency, has a built-in MCP server, and is MIT-licensed, all at once. mem0 requires Qdrant or Postgres and scored 49% on LongMemEval vs. Mnemosyne's 98.9%; Honcho requires Postgres plus three LLMs and is AGPL-licensed; ChromaDB is a vector database only and has no memory architecture. The main area where Mnemosyne trails is raw BEAM end-to-end QA, where Hindsight scores 73.4% vs. Mnemosyne's 65.2% at the 100K scale, per the README benchmark table. - Q: What are the main limitations or risks of using Mnemosyne? A: The BEAM retrieval recall@10 is reported as 20% flat across all dataset scales in the README's retrieval table, which means the system may not surface every relevant memory in a single query pass. Benchmark figures are self-reported and should be treated as directional until independently replicated. Vector search is an optional extra (`[all]`), so the base install falls back to keyword-only retrieval. Finally, the README notes that users are solely responsible for the content they store, and sync encryption must be explicitly enabled. - **PixelRAG** by startrail-org: Visual RAG pipeline that retrieves over screenshot tiles instead of parsed text, preserving tables, charts, and layout for more accurate document search. - Analog: https://analoghq.ai/es/startrail-org/software-tools/pixelrag - Source: https://github.com/StarTrail-org/PixelRAG - Install: `pip install pixelrag # Optional pipeline extras pip install 'pixelrag[embed]' pip install 'pixelrag[index]' pip install 'pixelrag[serve]'` - Repo: https://github.com/StarTrail-org/PixelRAG - Tags: rag, vision, open-source, cli, python, faiss, embeddings, agent - Pricing: free - Features: Renders web pages, PDFs, and images to screenshot tiles via headless Chromium (Playwright/CDP); Visual and text query search against a FAISS index of screenshot embeddings; Hosted endpoint with 8.28M Wikipedia pages pre-indexed, no API key required; Hybrid text-plus-image query support for multimodal retrieval; Claude Code plugin (pixelbrowse) for in-session visual page browsing; Modular pipeline: install only the stages (render, embed, index, serve) you need; LoRA-fine-tuned Qwen3-VL-Embedding-2B model with published adapters on Hugging Face; Self-hostable FAISS search API via FastAPI, CPU or GPU - Best for: Builders doing RAG over documents where tables, charts, or layout carry meaning that HTML parsing silently drops; Projects querying visually rich PDFs or web pages where text extraction loses critical structure; Claude Code users who want charts and tables visible to the model via the pixelbrowse plugin; Teams wanting to validate visual RAG quickly using the free, keyless hosted Wikipedia endpoint at api.pixelrag.ai; Pipelines needing visual-similarity or hybrid text-plus-image search over a screenshot index - Outcomes: A modular CLI pipeline covering render, chunk, embed, build-index, and serve stages that can be installed independently; A LoRA-fine-tuned Qwen3-VL-Embedding-2B model embedding screenshot tiles into a FAISS index for visual retrieval; Access to a pre-built index of 8.28M Wikipedia articles via api.pixelrag.ai, free and requiring no API key; A pixelbrowse Claude Code plugin that lets Claude read charts and tables locally with no MCP server or backend; Support for image queries and hybrid text-plus-image queries beyond standard text-to-screenshot retrieval - Caveats: Local indexing requires Python 3.12+ and a GPU or Apple Silicon, with a single PDF taking roughly 1 to 3 minutes; The base Wikipedia FAISS index is approximately 217 GB, making self-hosting a significant disk commitment; Bundled headless Chrome only auto-installs on linux-x64, requiring manual Chrome or Playwright Chromium setup elsewhere; Project originates from Berkeley SkyLab, BAIR, and Berkeley NLP, but maturity and production stability are not detailed in the content - Q: What is PixelRAG and how does it differ from standard RAG? A: PixelRAG is a visual retrieval-augmented generation pipeline that renders documents as screenshot tiles and retrieves over those images, rather than parsing text. Standard RAG pipelines parse HTML or PDF to plain text, discarding tables, charts, and visual layout in the process. PixelRAG keeps that structure intact by treating every page as an image, then using a vision-language embedding model to match queries against the visual content. It was developed at Berkeley SkyLab, BAIR, and Berkeley NLP. - Q: How do I install and run PixelRAG? A: Install the base package with `pip install pixelrag` (requires Python 3.12+), which gives you the `pixelshot` CLI for rendering pages to tiles. For a full local pipeline, install the index extra with `pip install 'pixelrag[index]'`, write a `pixelrag.yaml` config pointing at your documents, run `pixelrag index build`, then serve with `pixelrag serve`. You can also query the hosted Wikipedia index immediately, no setup or API key needed, via `curl -X POST https://api.pixelrag.ai/search`. - Q: Is PixelRAG free and open source? A: Yes, PixelRAG is released under the Apache-2.0 license and the full codebase is on GitHub. The hosted `api.pixelrag.ai` endpoint serving 8.28M Wikipedia pages is also free and requires no API key. Self-hosting your own index requires your own hardware and roughly 217 GB of disk for the base Wikipedia FAISS index. - Q: What is PixelRAG best for? A: PixelRAG is strongest when your documents are visually dense: pages with tables, charts, infographics, or layouts that text parsers would mangle. It is also a good fit for giving Claude Code visual browsing capability via the `pixelbrowse` plugin, letting Claude see charts and diagrams the way a person does instead of reading raw HTML. The hosted Wikipedia API makes it easy to validate the approach on a real-world scale before committing to a self-hosted index. - Q: How does PixelRAG compare to text-based RAG pipelines? A: Text-based RAG converts documents to plain text chunks, which silently drops tables, charts, and layout; PixelRAG renders to screenshot tiles and retrieves the images directly, preserving that visual structure. The tradeoff is infrastructure: PixelRAG requires a vision-language embedding model (Qwen3-VL-Embedding-2B), a FAISS index, and a rendering step, whereas text RAG pipelines are lighter to self-host. Per the README's research title, the Berkeley team found that screenshot-based retrieval beats text retrieval for web documents. - Q: What are the main limitations or requirements of PixelRAG? A: PixelRAG requires Python 3.12+ and works best with a GPU or Apple Silicon for embedding at reasonable speed, the README notes roughly 3 minutes per PDF on Apple M-series and 1 minute on GPU. The bundled turbo headless Chrome auto-installs only on linux-x64; macOS and Windows users need a system Chrome or Playwright's Chromium already installed. Downloading the base Wikipedia FAISS index locally is approximately 217 GB, making full self-hosting storage-intensive. The training environment pins specific versions (torch 2.9.1, transformers 4.57.1) in a separate project, though you do not need to retrain to use the published adapters. - **jscpd** by kucherenko: Un detector de copiar/pegar para código fuente compatible con más de 200 formatos, con un motor impulsado por Rust hasta 24-37x más rápido, trece reporteros, integración con CI y hooks de pre-commit, y salida lista para IA que incluye una skill de agente y un servidor MCP. - Analog: https://analoghq.ai/es/kucherenko/software-tools/jscpd - Source: https://jscpd.dev/ - Install: `npx jscpd` - Repo: https://github.com/kucherenko/jscpd - Tags: cli, open-source, rust, code-quality, linting, ci-cd, ai-ready, duplicate-detection - Pricing: free - Features: Detecta código duplicado en más de 220 formatos mediante Rabin-Karp; Motor Rust rápido (v5) hasta 24-37x más veloz, más un motor TypeScript; 13 reporteros que incluyen HTML, SARIF, badge y un reportero de IA eficiente en tokens; Git blame con comparación de autores en paralelo; Skills de agente instalables más un servidor REST y MCP; Integraciones con CI y hooks de pre-commit; Usado por GitHub Super Linter, Codacy y MegaLinter - Best for: Encontrar duplicaciones de copiar/pegar en una base de código; Aplicar DRY en CI o pre-commit; Alimentar datos de duplicación a un agente de IA - Outcomes: Bloques duplicados detectados con 13 reporteros; Motor Rust rápido (24-37x) para repositorios grandes; SARIF para GitHub Code Scanning; reportero de IA eficiente en tokens - Caveats: Detección basada en tokens (Rabin-Karp), no semántica; Algunas características de v4 (almacén LevelDB, JS API) aún no están en v5 - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué hace jscpd? A: Detecta bloques de código copiados y duplicados entre archivos en más de 220 formatos de lenguaje usando el algoritmo Rabin-Karp, ayudándote a mantener el código DRY. - Q: ¿Cuál es la diferencia entre los motores? A: v4 es el motor TypeScript/Node.js; v5 es una reescritura en Rust que es un reemplazo directo y funciona 24 a 37 veces más rápido como binario autocontenido sin necesidad de Node.js. - Q: ¿Pueden usarlo agentes de IA? A: Sí. Proporciona un reportero de IA eficiente en tokens, dos skills de agente instalables (referencia de herramienta y refactorización DRY) y un servidor REST/MCP, para que un agente pueda encontrar y corregir duplicaciones. - **Loading UI** by turbostarter: Una colección de spinners, loaders y animaciones de carga para aplicaciones web modernas, construida con React, Next.js, shadcn/ui, Tailwind CSS y Framer Motion. - Analog: https://analoghq.ai/es/turbostarter/software-tools/loading-ui - Source: https://loading-ui.com - Install: `npm i loading-ui` - Repo: https://github.com/turbostarter/loading-ui - Tags: open-source, react, tailwind, ui-components, animation, shadcn, copy-paste, mit - Pricing: free - Features: Spinners, loaders y animaciones de carga para aplicaciones web; Construido con React, Next.js, shadcn/ui y Tailwind CSS; Animaciones impulsadas por Framer Motion; Galería de componentes documentada en loading-ui.com/docs; Fácil de contribuir con nuevos componentes; Licencia MIT con una comunidad activa - Best for: Añadir spinners y animaciones de carga rápidamente; Proyectos React/Next.js con shadcn/ui y Tailwind; Contribuir con tus propios componentes de loader - Outcomes: Animaciones de carga listas para usar; Coherente con un stack moderno de React; Fácil de extender - Caveats: El alcance se limita a loaders y spinners únicamente; Vinculado al ecosistema de React y shadcn - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es Loading UI? A: Una colección de código abierto de spinners, loaders y animaciones de carga para aplicaciones web modernas, construida con React, Next.js, shadcn/ui, Tailwind CSS y Framer Motion. - Q: ¿Dónde está la documentación? A: La documentación y la galería de componentes están en loading-ui.com/docs. - Q: ¿Puedo contribuir con un componente? A: Sí. El proyecto está diseñado para facilitar las contribuciones; añadir tu propio componente lleva solo unos minutos según la guía de contribución. - **Nauval AI Components** by nauval: Open-source React component kit for agentic AI apps: streaming chat, tool calls, reasoning, citations, and more, SDK-agnostic and fully owned by your codebase. - Analog: https://analoghq.ai/es/nauval/software-tools/ai-components - Source: https://ai.nauv.al/ - Repo: https://github.com/nauvalazhar/ai - Tags: react, open-source, ui-components, ai-sdk, streaming, typescript, tailwind, agentic - Pricing: free - Features: Streaming-first rendering: reasoning, tool calls, and replies render as they arrive; Agentic surfaces: approvals, tasks, tool transcripts, and chain-of-thought are first-class components; Chat primitives: Message, Conversation, Composer, Composer Rich, Suggestion, Feedback Bar; Code surfaces: Code Block, Console, Diff, Diff Rich, Sandbox, Web Preview; File and media handling: Uploader, Attachment, Generated Image, Document; Primitive layer: Button, Chip, Menu, Player, Popover, Scroll Area, Select, Switch, Tooltip; Headless-style composition: each surface built from small, rearrangeable pieces; No vendor lock-in: zero opinions about the AI SDK or data layer - Best for: React teams building agentic or chat interfaces who want streaming-ready components without writing them from scratch; Projects needing full ownership of UI code, since components copy into your repo and are yours to modify; Teams already using Vercel AI SDK, LangChain.js, or any custom streaming source, as the library is SDK-agnostic; Builders who want accessibility baked in, including focus rings, keyboard navigation, and ARIA semantics from day one - Outcomes: A complete set of copy-paste React components covering streaming chat, tool call states, reasoning blocks, tasks, and approval flows; Code and output surfaces including Code Block, Diff, Sandbox, and Web Preview ready to drop into an agent harness; A primitive layer of Button, Chip, Menu, Scroll Area, and Tooltip with keyboard navigation and ARIA semantics pre-wired; TypeScript-first components with type safety handled before you write product code; Full repo ownership of every component, with no runtime dependency on the upstream library - Caveats: Copy-paste model means upstream bug fixes and improvements must be applied manually to your local copies; React is the only supported runtime, no Vue, Svelte, or other framework support is mentioned; Setup requires the aikit CLI init step to configure tokens, dependencies, and the cn helper before adding components - Q: What is Nauval AI Components? A: Nauval AI Components is an open-source React component library for building agentic AI interfaces, available at ai.nauv.al and github.com/nauvalazhar/ai. It provides copy-paste components for streaming chat, tool calls, reasoning blocks, citations, tasks, and code surfaces. Components are designed to be owned by your repo, you copy the source in, restyle with Tailwind or your own tokens, and ship it as part of your codebase. The library is SDK-agnostic and works with Vercel AI SDK, LangChain.js, or any other streaming source. - Q: How do I install and use it? A: Installation runs in two commands using the `aikit` CLI: `npx aikit init` writes `aikit.json` and sets up tokens, dependencies, and the `cn` helper, then `npx aikit add ` copies each component into your project with imports rewritten to your alias. Supported frameworks include Vite, Next.js, React Router, TanStack Start, and the shadcn CLI, with a manual path for setups where the CLI is not an option. The development playground, per the README, runs on port 3300 using `bun --bun run dev`. - Q: Is it free and open source? A: Yes, Nauval AI Components is free and open source, hosted publicly at github.com/nauvalazhar/ai. There is no runtime npm dependency on an upstream package, you copy the component source directly into your own repo. Full documentation, live demos, and copy-paste source are available at ai.nauv.al at no cost. - Q: What is it best for? A: Nauval AI Components is best for React developers building production-grade AI chat or agent interfaces who want full ownership of their UI layer. Its first-class support for streaming, tool calls, reasoning blocks, approvals, and tasks makes it particularly strong for agentic surfaces beyond simple chat boxes. Because it has no opinion about the data layer, it fits any stack using Vercel AI SDK, LangChain.js, or a custom streaming backend. Teams that want accessible, TypeScript-typed components without writing the plumbing from scratch will get the most out of it. - Q: How does it compare to shadcn/ui? A: Nauval AI Components uses the same copy-paste, own-your-code philosophy as shadcn/ui and even supports installation via the shadcn CLI, making it a natural companion rather than a competitor. The key difference is domain: shadcn/ui is a general-purpose component library, while Nauval AI Components is purpose-built for AI and agentic interfaces, shipping surfaces like Chain Of Thought, Tool Transcript, Reasoning, and Usage Meter that shadcn/ui does not cover. Teams already on shadcn/ui can layer in Nauval components for AI-specific surfaces without changing their existing setup. The primitives layer (Button, Chip, Menu, Tooltip, etc.) overlaps, but the agentic layer is where Nauval fills a di - Q: What are the main limitations? A: The main limitations are manual updates, React-only support, and a per-component install workflow. Because components are copied into your repo rather than imported from a versioned package, you apply upstream fixes yourself, there is no `npm update` path. The library is React-only, so Vue, Svelte, and vanilla JS projects are out of scope. Installing each component individually with `aikit add` keeps your bundle lean but requires an explicit step for every new surface you want. - **shadcn/ui** by shadcn: shadcn/ui, open-source, copy-owned UI components for developers building their own design system with full code control. - Analog: https://analoghq.ai/es/shadcn/software-tools/shadcn-ui - Source: https://ui.shadcn.com/ - Repo: https://github.com/shadcn-ui/ui - Tags: open-source, ui-components, design-system, cli, tailwind, react, ai-ready, mit-license - Pricing: free - Features: Copy-owned component model: source lands directly in your repo via CLI; 70+ accessible UI components including Charts, Sidebar, Data Table, and Chat primitives; Composable, predictable component interfaces across the entire library; Built-in CLI for fetching and distributing components with a flat-file schema; Custom registry support, including private GitHub registries; AI-ready open code: LLMs can read, reason about, and modify components; Theming, RTL, and form utilities included; MIT license - Best for: Teams building a custom design system who need full ownership of component source code; AI-assisted or agent-driven development workflows where LLMs need to read and modify UI code directly; Products that will inevitably deviate from library defaults and want to avoid style override hacks; Distributing a shared, customized component set across multiple projects via a private registry - Outcomes: Full component source code copied directly into your repo, with no abstraction layer between you and the markup; A composable, predictable component interface across 70+ primitives from Button and Input to Charts and Chat UI; A private or shared registry so teams can distribute their own customized component sets across projects; An AI-ready codebase where coding models and agents can reason about and rewrite components like a human would - Caveats: You own every bug fix and upgrade; improved upstream components must be merged manually, not version-bumped; The model demands active maintenance discipline, which is more demanding than a traditional NPM dependency; Not a component library in the conventional sense, so teams expecting a packaged API will need to adjust their mental model - Q: What exactly is shadcn/ui? A: shadcn/ui is an open-source set of accessible, beautifully designed UI components distributed as copyable source code rather than an installable NPM package. Per its own docs, it is not a component library but a foundation for building your own. You use its CLI to pull individual component files into your project, at which point you own the code outright and can modify it however you need. - Q: How do I add shadcn/ui components to my project? A: shadcn/ui ships a CLI tool that fetches component source files and writes them directly into your codebase using a flat-file schema. You run the CLI command for the component you want, and the files land in your project ready to edit. Full documentation, including installation steps for different frameworks, is available at ui.shadcn.com/docs. - Q: Is shadcn/ui free and open source? A: Yes. shadcn/ui is licensed under the MIT license, as stated in its GitHub repository. There are no paid tiers or commercial restrictions mentioned in the sources; the code is freely available on GitHub and can be used in personal and commercial projects. - Q: What is shadcn/ui best for? A: shadcn/ui is best for teams that need a design system they can fully own and customize, without fighting a third-party library's opinions. It is particularly well-suited to AI-assisted development workflows because every component is open, readable source code that LLMs can understand and modify directly, a capability the project explicitly calls out as a core design principle. - Q: How does shadcn/ui differ from a traditional component library like MUI or Chakra? A: Traditional libraries ship compiled packages you install via NPM; customization means wrapping components or overriding styles, and you rely on the library's release cycle for fixes. shadcn/ui instead copies raw component source into your repo, giving you full transparency and edit access. The tradeoff is that you own all future maintenance: upgrading a component means manually merging changes rather than bumping a semver number. - Q: What are the main limitations of shadcn/ui? A: The copy-ownership model means component upgrades are manual rather than automatic, which increases maintenance burden as the upstream project evolves. Teams managing many repositories may find distributing and keeping components in sync across projects more complex, though the built-in registry system is designed to help with this. The flat-file, open-code approach also assumes developers are comfortable reading and modifying component internals, which is less suitable for teams that prefer abstracted, zero-touch dependencies. - **theSVG** by thesvg: Open-source brand SVG icon library with 6,149+ typed, tree-shakeable icons for developers and designers. - Analog: https://analoghq.ai/es/thesvg/software-tools/thesvg - Source: https://thesvg.org/ - Tags: svg, icons, open-source, typescript, react, vue, svelte, cli - Pricing: free - Features: 6,149+ brand SVG icons with typed metadata (hex, title, categories, variants); Tree-shakeable per-icon imports for ESM and CJS builds; Typed React, Vue 3, and Svelte component packages; shadcn-style CLI installer, copies SVG locally, zero runtime dep; MCP server for Claude, Cursor, and Windsurf tool calls; CDN delivery via jsDelivr for HTML, CSS, and markdown use; VS Code extension with command-palette search, copy SVG/JSX/CDN; Figma plugin with variant picker and keyboard shortcuts - Best for: Apps that display third-party brand logos and want a single versioned npm dependency; Projects needing typed, tree-shakeable brand SVGs with structured metadata like hex colors and categories; Teams using React, Vue 3, or Svelte who want drop-in framework adapter components; Static projects or CSP-restricted apps that need icons copied directly into the project via CLI - Outcomes: 6,149+ brand SVG icons available as a single npm install with zero manual SVG hunting; Per-icon TypeScript types, hex color values, title, categories, and SVG variants out of the box; Tree-shakeable packages so only imported icons land in the final bundle; Shadcn-style CLI to copy SVGs directly into the project, removing the runtime dependency entirely; MCP server, Figma plugin, and CDN path available as additional integration surfaces - Caveats: Project is new with 49 releases in roughly three months, signaling fast iteration but potential instability; Frequent version bumps mean production apps should lock versions and treat minor updates cautiously; Website and CDN show 6,149+ icons but the npm package at v3.0.15 documents 3,800+, a gap worth checking before assuming full coverage; Individual icons carry their respective upstream brand licenses, not just the library MIT license - Q: What is theSVG? A: theSVG is an open-source brand SVG icon library that packages 6,149+ brand logos as typed, tree-shakeable npm modules. Each icon ships with its raw SVG string, hex color, title, category tags, and multiple variants (default, mono, dark). The library is MIT licensed for the package code, with individual icons carrying their upstream brand licenses. - Q: How do I install and use theSVG in a project? A: Run `npm install thesvg` to add the convenience package. You can then import per-icon with `import github from 'thesvg/github'` to access `github.svg`, `github.hex`, and `github.variants`, or use a barrel import like `import { github, vercel } from 'thesvg'` for multiple icons. For React, the `@thesvg/react` package provides typed forwardRef components; Vue 3 and Svelte have their own adapter packages. The CLI (`npx @thesvg/cli add github`) copies the SVG directly into your project with no runtime dependency, which is useful for static sites or CSP-restricted apps. - Q: Is theSVG free and open source? A: Yes, the npm package is published under the MIT license, first released March 8, 2026, per the npm registry. The package code is freely usable in commercial and open-source projects. Individual icons carry their respective upstream brand licenses, so teams with strict brand-usage legal requirements should review those separately. A paid REST API is listed as planned at api.thesvg.org but has not launched yet. - Q: What is theSVG best for? A: theSVG is best for web apps that display third-party brand logos, such as a tech-stack section, an integration directory, or a fintech app showing payment provider marks. Its typed metadata (hex colors, categories, variants) eliminates manual brand-color lookups, and per-icon tree-shaking keeps bundle size proportional to what you actually use. It also integrates with AI agents via an MCP server compatible with Claude, Cursor, and Windsurf, making it useful in agentic UI generation workflows. - Q: How does theSVG compare to simple-icons or other brand icon libraries? A: simple-icons, the closest established alternative, provides around 3,200 brand SVGs as raw files with minimal metadata and no typed framework packages. theSVG adds per-icon TypeScript types, hex color variants, an MCP server, and ready-made React/Vue/Svelte components, making it more ergonomic for typed codebases and agent-driven workflows. The tradeoff is maturity: simple-icons has years of community vetting behind it, while theSVG shipped its first version in March 2026 and has moved through 49 releases in roughly three months, so it carries more churn risk for production applications. - Q: What are the limitations and risks of using theSVG? A: The most concrete risk is version churn: 49 npm releases between March and June 2026 signals an actively evolving API, and production apps should pin to a specific version and test upgrades deliberately rather than accepting automatic minor updates. There is also a documented icon-count discrepancy, the npm package at version 3.0.15 states 3,800+ icons while the website and extensions page advertise 6,149+, so the exact available set depends on which surface you use. Finally, the library covers brand logos only; it is not a substitute for a general-purpose UI icon set, and each icon's brand license must be reviewed independently for commercial use. - **Streamline Pixel Icons** by streamline: Streamline Pixel Icons: a 442k-icon library with 34 families, Figma plugin, and VS Code extension for designers and developers who need consistent, large-scale icon sets. - Analog: https://analoghq.ai/es/streamline/software-tools/streamline-pixel - Source: https://www.streamlinehq.com/icons/pixel - Tags: icons, design, figma, svg, png, open-source, ui, illustration - Pricing: freemium - Features: 442,614 icons across 34 families and 172 sets; All icons designed in-house by 8 dedicated icon designers; Multiple style families: Core (minimal), Sharp (brutalist), Pixel (retro), Freehand (hand-drawn), Plump (friendly), and; 20+ illustration families including Brooklyn, Milano, and London styles; 20,000+ emoji sets available as free customizable vectors; Figma plugin with 454k users for in-file icon browsing and insertion; VS Code extension for developer icon access without leaving the editor; Curated open-source sets (Phosphor, Remix, Tabler, Lucide) searchable in one place - Best for: Teams building large design systems that need cohesive icon coverage across many concepts and styles; Designers who live in Figma and want a single plugin for browsing, copying, and downloading icons as SVG or PNG; Developers who prefer staying in VS Code and need to browse and insert icons without switching tools; Projects requiring a distinct visual language, such as brutalist, retro pixel, hand-drawn, or rounded friendly styles; Teams extending Google Material and wanting a consistent pro-grade expansion of that icon set - Outcomes: Access to 442,614 icons across 34 families and 172 sets, all designed in-house for guaranteed visual cohesion; A locked-in consistent visual language per project by selecting a single family such as Sharp, Plump, Pixel, or Freehand; SVG and PNG exports directly from Figma or VS Code without leaving the design or development environment; Encyclopedic concept coverage, including rare concepts, through families like Ultimate Bold with over 18,000 icons - Caveats: Full 442k library access requires a paid plan; free tier offers roughly 1,000 icons per style across select families; The Figma plugin is an in-app purchase, not fully free at the point of integration; 20,000+ emoji vectors are noted as free on the site, but this is a subset of the broader paid offering; Library is proprietary and in-house designed, so there is no open-source or community-contributed fallback - Cost note: ["Free tier includes approximately 1,000 icons per style for Ultimate Light, Regular, Bold, Colors, and Duotone families, plus free emoji vectors. Full access to all 442,614 icons requires a paid plan. Figma plugin access is listed as an in-app purchase."] - Q: What is Streamline and what does it include? A: Streamline is a commercial icon library containing 442,614 icons across 34 families and 172 sets, all designed in-house over 12 years. Beyond icons, it includes 20+ illustration families, 20,000+ free vector emojis, and UI elements like abstract shapes, patterns, and hand-drawn sketches. It also curates popular open-source sets like Phosphor, Remix, Tabler, and Lucide, searchable within the same interface. - Q: How do I use Streamline in Figma or my code editor? A: Designers can install the Streamline Figma plugin (over 454k users) to browse and insert icons directly into their files; the plugin is an in-app purchase for full access. Developers can use the VS Code extension to browse by tags, themes, or styles and copy icons without leaving the editor. Icons are available as SVG or PNG downloads from the main site as well. - Q: Is Streamline free or does it cost money? A: Streamline has a free tier that includes 1,000 icons per style variant (Light, Regular, Bold, Colors, Duotone) within the Ultimate family, plus all 20,000+ emoji sets as free vectors. Full access to the complete 442,614-icon library requires a paid plan; the Figma plugin is listed as an in-app purchase. Exact pricing tiers are not detailed in the publicly available sources. - Q: What is Streamline best suited for? A: Streamline is best for teams building design systems or products that demand visual consistency at scale. Its in-house design approach means every family shares a coherent underlying grid and proportions, reducing the visual friction that comes from mixing icons sourced from different libraries. The breadth of styles (minimal, brutalist, pixel, hand-drawn) means a single subscription can serve multiple brand contexts. - Q: How does Streamline compare to open-source icon libraries like Phosphor or Lucide? A: Streamline's proprietary families are designed to be 50x larger than the industry average, per the company, with a single family like Ultimate Bold exceeding 18,000 icons, whereas most open-source libraries cover a few hundred to a few thousand icons. Streamline also includes the top open-source sets (Phosphor, Remix, Tabler, Lucide) as curated additions, so it can serve as a superset rather than a replacement. The tradeoff is cost: open-source libraries are fully free, while Streamline's full library requires a paid plan. - Q: What are the main limitations of Streamline to be aware of? A: The primary limitation is cost: the free tier caps out at 1,000 icons per style variant, and full access is behind a paid subscription or in-app purchase in Figma. If your project only needs a small, standard icon set and cost is a hard constraint, a free-only library may be sufficient. Additionally, niche style families like Pixel or Freehand are distinctive in aesthetic, which means they suit specific brand voices and may not translate well to all product contexts. - **Awwwards** by awwwards: Awwwards: the industry benchmark for web design excellence, offering awards, inspiration galleries, a professional directory, courses, and a curated marketplace for designers and developers. - Analog: https://analoghq.ai/es/awwwards/software-tools/awwwards - Source: https://www.awwwards.com/ - Tags: design, awards, inspiration, web-design, community, directory, courses, marketplace - Pricing: freemium - Features: Daily, monthly, and annual website awards judged by an expert jury; Browsable inspiration gallery filtered by category, technology, and visual style; Curated collections (e.g. tools, animations, color palettes) with community following; Vetted directory of 6,038+ agencies, freelancers, and studios with award counts; Hundreds of Academy courses on UI, Figma, branding, and web design; Marketplace for Framer, Webflow, and Figma digital product templates; Nominee voting system open to the community; Blog covering design trends, platform comparisons, and typography - Best for: Designers and frontend developers seeking a credible benchmark for current web design excellence; Studios and agencies wanting to earn industry-recognized badges that carry professional weight; Builders needing to filter inspiration by specific tech stacks like React, WebGL, GSAP, Framer, or Webflow; Teams sourcing vetted agencies or professionals from a directory of over 6,038 tagged entries; Designers looking for structured courses covering UI design in Figma, branding, and full web workflows - Outcomes: A daily, monthly, and yearly ranked gallery of winning sites scored numerically out of 10, making quality concrete and comparable; An industry-recognized badge upon winning that carries real credentialing weight with clients and peers; Filtered inspiration browsable by technology, category, and visual style for targeted reference gathering; Access to hundreds of Academy courses and themed collections grouping references by topic; Ready-made Framer, Webflow, and Figma templates available for purchase via the Market - Caveats: Jury scoring favors aesthetic and animation richness, so performance-optimized or accessibility-focused sites rarely top the leaderboard; Pro membership is required for some platform features, adding cost beyond free browsing; Academy courses carry separate pricing from platform membership, though a Creative Pass is available - Cost note: ["Market templates start around $99. Academy courses are priced separately, with a Creative Pass available for around $12 per month per the site. Some platform features require a Pro membership."] - Q: What is Awwwards? A: Awwwards is a web design awards platform that recognizes the best websites globally, judged by an expert jury that scores submissions on design, usability, creativity, and content. Each day it names a Site of the Day, with scores expressed as numerics out of 10. Beyond awards, it also hosts a professional directory, an Academy with hundreds of design courses, curated inspiration collections, and a marketplace for digital templates. - Q: How do I submit a website or use Awwwards as a designer? A: Designers and agencies can submit a website directly through the platform for jury review. If scored highly enough, the site earns a Site of the Day, Month, or Year badge. Professionals can also create a directory profile listing their works and award counts, making the platform a credentialing tool as well as an awards venue. A Pro membership unlocks additional features on the platform. - Q: Is Awwwards free to use? A: Browsing the gallery, collections, and directory on Awwwards is free. A Pro membership is available for access to additional platform features. Academy courses are priced separately, with a Creative Pass subscription available for approximately $12 per month per the site. Marketplace templates are paid products, with prices starting around $99. - Q: What is Awwwards best for? A: Awwwards is best for designers and frontend developers who want a daily, juried benchmark of what excellent web design looks like right now. Its technology-filtered gallery (covering WebGL, GSAP, React, Figma, Framer, Webflow, Shopify, and more) makes it practical for finding real-world implementation examples, not just generic mood boards. It is also the go-to platform for agencies and studios seeking industry-recognized credentialing. - Q: How does Awwwards compare to other design inspiration sources? A: Unlike broad design aggregators, Awwwards uses a numeric jury score for every winning site, making quality ranking explicit rather than purely editorial. Its directory ties 6,038+ professionals and agencies to their award history, adding a credentialing layer most inspiration galleries lack. The trade-off is that the gallery strongly favors visually spectacular, animation-heavy work, so sites optimized for accessibility or content density are underrepresented compared to what you might find on broader design directories. - Q: What are the main limitations of Awwwards? A: The award scoring system favors visual craft and interactive animation, meaning performant, accessible, or content-first sites rarely surface to the top of the leaderboard. Pro features are gated behind a membership, and Academy courses require a separate subscription or per-course purchase. The platform is also focused on web-facing design work, so it offers little value for product designers, motion designers, or print designers who are not building public-facing sites. - **ScanRepo** by scanrepo: Free repo scanner that checks GitHub and Bitbucket projects for malware, credential stealers, and crypto scams before you run their code. - Analog: https://analoghq.ai/es/scanrepo/software-tools/scanrepo - Source: https://www.scanrepo.dev/ - Tags: security, open-source, malware, supply-chain, osint, github, cli, developer-tools - Pricing: free - Features: Scans GitHub and Bitbucket repo URLs for malware and scams; Detects code execution patterns: eval(), Function(), child_process; Flags data exfiltration via suspicious domains and hardcoded IPs; Identifies credential theft targeting browser profiles, wallets, SSH keys; Spots hex encoding and minified source obfuscation; Detects malicious install scripts and supply chain package abuse; Trending Repos view for scanning currently popular GitHub projects; Live OSINT Intel feed aggregating npm advisories, security news, and scam reports - Best for: Developers vetting unfamiliar GitHub or Bitbucket repos before cloning or running them locally; Teams doing quick supply chain checks on trending open source projects; Anyone auditing repos that use postinstall scripts or pull in dependency chains; Security-conscious builders who want OSINT threat context alongside individual scan results - Outcomes: A red flag report covering eval(), Function(), child_process, hardcoded exfiltration endpoints, and obfuscation patterns; Detection of credential theft targeting browser profiles, crypto wallets, and SSH keys; Visibility into malicious install scripts and flagged packages in the dependency chain; Access to a Trending Repos view for scanning popular projects before pulling them locally; An Intel feed aggregating npm advisories, GitHub Advisory Database, Socket.dev, OSSF, VirusTotal, PhishTank, and abuse.ch - Caveats: Static pattern matcher only, not a sandbox executor, so it will not catch every obfuscation technique; Threat actors who deliberately avoid the checked patterns can evade detection; OSSF corpus covers 15,000+ confirmed malicious package reports, but live feeds depend on upstream sources; Treat a clean scan as a useful first pass, not a security guarantee - Cost note: ScanRepo is free to use with no installation required, paste a URL and get results immediately. - Q: What is ScanRepo? A: ScanRepo is a free web-based security scanner that checks GitHub and Bitbucket repositories for hidden malware, credential stealers, crypto scams, and supply chain threats. You submit a repo URL and it analyzes the source for dangerous patterns including eval() calls, suspicious outbound domains, wallet and SSH credential theft, and obfuscated code. It is built by @rubenmarcus and draws on a dataset of known malicious repositories. - Q: How do I use ScanRepo? A: Navigate to scanrepo.dev, paste a GitHub or Bitbucket repository URL into the scanner, and submit. ScanRepo performs a static analysis against its threat categories and returns a report. No account, installation, or CLI setup is required. The Trending Repos tab also lists currently popular GitHub projects you can scan in one click. - Q: Is ScanRepo free or open source? A: ScanRepo is free to use via its web interface at scanrepo.dev. The sources do not specify an open-source license or link to a public codebase for the scanner itself, so its licensing status beyond being freely accessible is unclear. - Q: What is ScanRepo best for? A: ScanRepo is best used as a fast first-pass check before cloning or running any unfamiliar repository, especially trending projects or anything that executes a postinstall script. It is particularly useful for developers onboarding new dependencies, reviewing third-party tooling, or keeping up with active supply chain campaigns via its live OSINT Intel feed. - Q: How does ScanRepo compare to running a full sandbox or other security tools? A: ScanRepo is a static pattern matcher: it scans source code for known threat signatures without executing the code. Full sandbox tools actually run the code in an isolated environment to catch runtime behavior that evades static analysis. ScanRepo's Intel feed also aggregates sources like OSSF Malicious Packages (15,000+ confirmed reports), Socket.dev, and VirusTotal, but those are reference links rather than a deeper dynamic analysis layer. Use ScanRepo for speed and breadth; use execution sandboxes when you need behavioral confirmation. - Q: What are ScanRepo's limitations? A: Because ScanRepo relies on static pattern matching, it can miss novel obfuscation techniques or threat actors who deliberately avoid its detection heuristics. A clean result signals the absence of known patterns, not a guarantee the repo is safe. The Intel feed depends on external sources updating in a timely way, and the sources do not clarify how frequently the scanner's own ruleset is updated. - **loaders.wtf** by dcp: Open-source file-format loaders for geospatial, tabular, and 3D data, with worker-thread and streaming support for big-data JS apps. - Analog: https://analoghq.ai/es/dcp/software-tools/loaders-wtf - Source: https://www.loaders.wtf/ - Tags: open-source, geospatial, data-loading, 3d, streaming, workers, visualization, javascript - Pricing: free - Features: Unified load/save API across dozens of geospatial, tabular, and 3D formats; Streaming incremental parsing via async iterators for files larger than memory; Pre-built web workers for off-main-thread parsing on supported loaders; Browser and Node.js LTS support with consistent behavior; Composable module system: install only the format loaders you need; Framework-agnostic output: plain JS objects and typed arrays; Loader categories enforce standardized output shapes across similar formats; Pre-integrated with deck.gl and other vis.gl frameworks - Best for: Apps handling multiple geospatial or 3D formats (shapefiles, glTF, Arrow, CSVs, point clouds) through one unified API; Teams already using deck.gl or the vis.gl ecosystem, where integration is pre-wired out of the box; Pipelines needing streaming ingestion via loadInBatches without rewriting data handling logic; Analytics pipelines requiring columnar Arrow table output rather than row-object formats - Outcomes: A single load and loadInBatches call signature that works across every supported format, so format swaps do not rewrite pipelines; Modular install: only the format modules your stack needs are added, keeping unused formats out of the bundle; Parse work moved off the main thread via pre-built web workers shipped with many loaders; Columnar Arrow table output from modules like @loaders.gl/arrow, compatible with analytics pipelines expecting columnar memory - Caveats: Full worker performance requires COOP/COEP security headers and SharedArrayBuffer access, graceful fallback loses off-thread benefit; Library is tuned around vis.gl usage patterns, which may feel over-fitted if your stack is outside that ecosystem; Currently at v4, MIT licensed, open source; Each format module must be installed individually alongside the small @loaders.gl/core base - Q: What is loaders.gl? A: loaders.gl is an open-source (MIT) JavaScript library at v4 that provides a unified API for loading and writing tabular, geospatial, and 3D file formats. It ships as a small core module plus optional format-specific modules (CSV, Arrow, glTF, Shapefile, and more), each returning parsed data as plain JavaScript objects or typed arrays. The library runs in browsers, Node.js LTS, and web workers, and comes pre-integrated with the deck.gl visualization framework. - Q: How do I install and use loaders.gl in my project? A: Install `@loaders.gl/core` plus whichever format module you need (for example `@loaders.gl/csv`), then call `load('data.csv', CSVLoader)` to get a JavaScript array of row objects. For files larger than memory, use `loadInBatches` with an async iterator: `for await (const batch of await loadInBatches('data.csv', CSVLoader))`. The docs at loaders.gl/docs include a Get Started guide that walks through both patterns in TypeScript. - Q: Is loaders.gl free and open source? A: Yes. loaders.gl is released under the MIT license, making it free to use, modify, and redistribute in both commercial and open-source projects. It is published as a suite of composable npm modules, so you only install the loaders your application actually needs. - Q: What is loaders.gl best for? A: loaders.gl is best for JavaScript applications that must handle multiple geospatial or 3D file formats, especially when streaming large files or offloading parse work to web workers. It is the natural choice for teams building on deck.gl or other vis.gl frameworks, and for Node.js backend services that need the same format support as the browser client. If your app only consumes a single lightweight format like GeoJSON, a narrower library avoids the extra module weight. - Q: How does loaders.gl compare to format-specific libraries? A: loaders.gl's core advantage over single-format libraries is a unified API: swapping `CSVLoader` for `ArrowLoader` (or a 3D loader) requires no changes to the surrounding data pipeline. Format-specific libraries often expose idiosyncratic APIs and offer no worker or streaming support. The tradeoff is that loaders.gl's module system adds some bundle overhead, and some modules (like `@loaders.gl/arrow`) return columnar Arrow tables rather than row objects, which can surprise developers expecting row-oriented output from every loader. - Q: What are the main limitations or gotchas? A: Worker-thread parsing requires the browser deployment to set Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy (COOP/COEP) headers to enable SharedArrayBuffer; without those headers, loaders fall back to the main thread and you lose the off-thread benefit. The Arrow module returns columnar memory layouts, not row arrays, so downstream code must account for both output shapes. Pre-integration with vis.gl means the library is optimized for deck.gl usage patterns, which may not align perfectly with unrelated stacks. Finally, if your only format is GeoJSON and you need no workers or streaming, lighter alternatives will reduce bundle size. - **agentcn** by shadcn-labs: Free, open-source shadcn-style registry of production-ready AI agent recipes for developers who want full code ownership with zero config. - Analog: https://analoghq.ai/es/shadcn-labs/software-tools/agentcn - Source: https://agentcn.run - Install: `pnpm dlx shadcn add @agentcn/eve/browser-agent npx shadcn@latest add @agentcn/eve/deep-search pnpm dlx shadcn@latest add @agentcn/flue/deep-search` - Repo: https://github.com/shadcn-labs/agentcn - Tags: open-source, agent, registry, shadcn, copy-paste, vercel, mit, recipes - Pricing: free - Features: Copy-paste agent recipes via the shadcn CLI with no runtime dependency; Full agent source included: definition, instructions, tools, skills, workflows; Dual-framework support: Eve (Vercel Functions) and Flue (subagents, bounded workflows); Zero config setup with production-ready defaults; Company Knowledge recipe with libSQL vector store and PII redaction; Composable: swap model, vector store, or tools without fighting a library; MIT licensed with community contribution model via Pull Request; Live previews: run each agent directly from its docs page - Best for: Teams that want full code ownership over agent logic without being locked into an opaque runtime dependency; Builders already familiar with the shadcn copy-paste model who want to apply it to backend AI agents; Projects that need to customize instructions, tools, or workflows heavily from day one; Developers using Eve or Flue frameworks who want production-ready starting points - Outcomes: Full agent source lands in your repo via one npx shadcn CLI command, with no runtime dependency added; Each recipe includes an agent definition, Markdown instructions file, typed tools, and workflow logic you can read in minutes; Clear swap points documented per recipe, such as replacing the vector store or tuning PII redaction patterns; Zero framework lock-in since you own every file and can change the model, tools, or data layer freely - Caveats: Copy-paste ownership means agentcn updates never flow to your codebase automatically, you must apply them manually; Recipe availability is tied to Eve and Flue frameworks, so teams on other runtimes may need to adapt; Registry is early stage and breadth of available recipes is not specified in current docs - Q: What is agentcn? A: agentcn is a free, open-source registry of production-ready AI agent recipes modeled after shadcn/ui but for backend agents. Each recipe ships the full agent source, including an agent definition file, a Markdown instructions file, typed tools, and workflow logic. You copy the files into your own project with the shadcn CLI and own every line from day one. The registry is hosted at agentcn.run and the source is on GitHub under the MIT license. - Q: How do I install an agentcn recipe? A: Run `npx shadcn@latest add @agentcn//` in your project root, replacing the placeholders with the framework (eve or flue) and the recipe slug you want. The CLI copies the agent files directly into your project. For recipes with additional dependencies, the docs list an `npm install` command for packages like `eve`, `@libsql/client`, `@ai-sdk/openai`, and `ai`. - Q: Is agentcn free and open source? A: Yes, agentcn is free and released under the MIT license, per the GitHub repository. There is no paid tier for the registry itself. Running the agents may incur costs from third-party services you configure: Vercel Functions for Eve-based recipes, your chosen vector store (libSQL, Pinecone, pgvector), and any model provider like OpenAI. - Q: What is agentcn best for? A: agentcn is best for developer teams who want to ship a working AI agent quickly without giving up the ability to read, customize, and extend every part of it. The docs call out internal tooling as a primary use case: document Q&A assistants, knowledge bases, and workflow automation. It pairs especially well with teams already using the shadcn CLI and deploying on Vercel with Eve. - Q: How does agentcn compare to agent libraries like LangChain? A: agentcn copies full agent source directly into your project; LangChain and similar libraries ship as opaque packages you import and depend on at runtime. The practical difference: with agentcn you can read, modify, and extend every line without working around the library's abstractions, but you also own the upgrade path manually. Per the docs, agentcn explicitly takes the opposite approach to 'black box' agent packages, trading automatic patch delivery for zero lock-in and direct access to framework primitives. - Q: What are the main limitations of agentcn? A: The copy-paste model means that when the agentcn registry publishes an improved version of a recipe, that update does not flow automatically to your project the way an `npm update` would. You need to manually re-copy or diff changes. Additionally, recipes are built on Eve or Flue, so projects on other agent runtimes will need to add one of those frameworks. The current size of the recipe catalog is not published on the site, so browsing agentcn.run is the best way to check current coverage before committing to the tool. - **ASCII Magic** by kail-designs: Una herramienta de navegador gratuita y sin registro que convierte fotos y videos en arte ASCII y otros 12 estilos: pixel art, voxel, mosaico, semitono, glitch, LEGO y más, con vista previa en tiempo real, efectos de posprocesamiento retro y exportación de hasta 4x de resolución. - Analog: https://analoghq.ai/es/kail-designs/software-tools/ascii-magic - Source: https://www.ascii-magic.com/ - Tags: ascii, image-processing, open-source, python, browser-tool, creative, no-signup, generative-art - Pricing: free - Features: Convierte fotos y videos en arte ASCII y otros 12 estilos; Los estilos incluyen pixel art, voxel, mosaico, semitono, glitch y LEGO; Posprocesamiento retro: líneas de exploración, curvatura CRT, bloom, grano de película y separación RGB; Vista previa en tiempo real que se actualiza al instante; Exportación con hasta 4x de resolución; Se ejecuta en el navegador sin registro, de uso gratuito - Best for: Convertir fotos o video en arte ASCII y retro; Crear visuales estilizados rápidamente para proyectos sociales o creativos; Experimentar con efectos en tiempo real sin necesidad de instalación - Outcomes: Arte ASCII y otros 12 estilos a partir de cualquier imagen o video; Posprocesamiento retro y exportación de hasta 4x; Todo en el navegador, sin registro - Caveats: No está basado en IA; el asistente Ask AI simplemente enlaza a ChatGPT o Claude; Basado en el navegador; sin API pública ni repositorio - Cost note: Completamente gratuito, sin registro. - Privacy note: Procesa los archivos multimedia directamente en tu navegador; no se requiere cuenta. - Q: ¿Qué hace ASCII Magic? A: Es un estilizador gratuito basado en el navegador que convierte tus fotos y videos en arte ASCII y otros doce estilos, como pixel art, voxel, mosaico, semitono, glitch y LEGO, con vista previa en tiempo real y exportación en alta resolución. - Q: ¿Usa IA? A: No. La conversión principal de imágenes y videos se ejecuta localmente en tu navegador y no está basada en IA. Ofrece un asistente opcional Ask AI que te redirige a ChatGPT o Claude para obtener explicaciones. - Q: ¿Es gratuito y necesito una cuenta? A: Sí, es completamente gratuito y no requiere registro; procesa los archivos multimedia directamente en tu navegador. - **Boneyard** by 0xgf: Un framework de carga skeleton que genera pantallas de carga pixel-perfect a partir de tu interfaz real, sin mediciones manuales ni marcadores de posición ajustados a mano, para React, Preact, Vue, Svelte 5, Angular y React Native. - Analog: https://analoghq.ai/es/0xgf/software-tools/boneyard - Source: https://boneyard.vercel.app/ - Install: `npx boneyard` - Repo: https://github.com/0xGF/boneyard - Tags: open-source, ui, react, vue, svelte, loading, cli, vite - Pricing: free - Features: Skeletons pixel-perfect capturados automáticamente desde tu interfaz real; Compatible con React, Preact, Vue, Svelte 5, Angular y React Native; CLI o plugin de Vite captura diseños en múltiples breakpoints; Formato de salida `.bones.json` multiplataforma; Integración con React Suspense mediante `BoneSuspense`; Animaciones pulse, shimmer o solid con colores claro y oscuro; Captura en dispositivo para React Native con cero sobrecarga en producción - Best for: Skeletons pixel-perfect sin ajuste manual; Equipos con múltiples frameworks (React, Vue, Svelte y más); Skeletons de React Native capturados en el dispositivo - Outcomes: Skeletons adaptados a tu interfaz real; Un único formato bones para todos los frameworks; Integración con Suspense y escalado de Dynamic Type - Caveats: Requiere un paso de captura en tiempo de compilación o mediante navegador sin interfaz gráfica; Los huesos deben regenerarse cuando cambia la interfaz - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es Boneyard? A: Un framework que genera pantallas de carga skeleton pixel-perfect capturando el diseño de tus componentes reales, para que no tengas que medir ni ajustar marcadores de posición a mano. - Q: ¿Cómo funciona la captura? A: Una CLI o plugin de Vite abre un navegador sin interfaz gráfica, visita tu aplicación, encuentra cada `Skeleton` nombrado y captura su diseño en múltiples breakpoints en un archivo `.bones.json`; React Native mide las vistas en el dispositivo en modo desarrollo. - Q: ¿Qué frameworks son compatibles? A: React, Preact, Vue, Svelte 5, Angular y React Native, todos produciendo el mismo formato bones multiplataforma. - **LiquidGlass** by ybouane: Una biblioteca de efecto liquid-glass para la web: aplica refracción de vidrio realista, desenfoque, aberración cromática e iluminación a cualquier elemento HTML mediante shaders WebGL. - Analog: https://analoghq.ai/es/ybouane/software-tools/liquidglass - Source: https://liquid-glass.ybouane.com/ - Install: `npm i @ybouane/liquidglass` - Repo: https://github.com/ybouane/liquidglass - Tags: webgl, animation, ui, open-source, typescript, javascript, glass-morphism, frontend - Pricing: free - Features: Efectos de vidrio realistas en cualquier elemento HTML mediante shaders WebGL; Refracción, aberración cromática, reflexión Fresnel, especular y sombra; `data-config` por elemento para un ajuste detallado; Composición en capas para que los paneles de vidrio apilados se refracten entre sí; Modos interactivos de flotación (drag) y botón; Reactivo a cambios del DOM mediante `MutationObserver`, con contador de FPS; Instalable desde npm o importable directamente desde un CDN - Best for: Refracción de vidrio realista en la web mediante WebGL; Uso agnóstico de framework en cualquier elemento HTML; Ajuste detallado de vidrio por elemento - Outcomes: Refracción, aberración e iluminación convincentes; Configuración por elemento mediante atributos de datos; Vidrio en capas que refracta los paneles inferiores - Caveats: Los elementos de vidrio deben ser hijos directos del contenedor raíz; Capturar el DOM en un canvas es costoso; cada instancia abre su propio contexto WebGL - Cost note: Gratuito y de código abierto. - Q: ¿Qué hace LiquidGlass? A: Aplica vidrio realista, refracción, desenfoque, aberración cromática, reflexión Fresnel, resaltes especulares y una sombra paralela a cualquier elemento HTML mediante shaders WebGL. - Q: ¿Cómo se usa? A: Instálalo desde npm (o impórtalo desde un CDN), llama a `LiquidGlass.init` con un contenedor raíz y tus elementos de vidrio, y configura cada panel con un JSON `data-config` de opciones como refraction, blur y corner radius. - Q: ¿Pueden solaparse los paneles de vidrio? A: Sí. Utiliza composición en capas y reimplementa las reglas de stacking de CSS, de modo que un panel de vidrio situado sobre otro lo ve en su refracción; los elementos de vidrio deben ser hijos directos del contenedor raíz. - **Shannon** by keygraphhq: Un pentester de IA autónomo y de caja blanca para aplicaciones web y APIs; analiza el código fuente, identifica rutas de ataque y ejecuta exploits reales para demostrar vulnerabilidades con una prueba de concepto funcional. Ejecútalo localmente (código abierto) o a través de la plataforma Keygraph. - Analog: https://analoghq.ai/es/keygraphhq/software-tools/shannon - Source: https://keygraph.io/ - Install: `npm i shannon` - Repo: https://github.com/KeygraphHQ/shannon - Tags: open-source, security, pentesting, cli, agent, docker, appsec, self-hosted - Pricing: free - Features: Pentester de IA autónomo de caja blanca para aplicaciones web y APIs; Combina el análisis de código fuente con la explotación en vivo; Informa únicamente las vulnerabilidades con una prueba de concepto funcional; Un solo comando ejecuta el reconocimiento, el análisis, la explotación y la generación de informes; Pruebas autenticadas con flujos de inicio de sesión, TOTP y reglas de compromiso; Se centra en inyección, XSS, SSRF y fallos de autenticación según OWASP; CLI de código abierto (AGPL-3.0); también impulsa la plataforma Keygraph - Best for: Pentesting automatizado de caja blanca para aplicaciones web y APIs; Pruebas de seguridad continuas entre pentests anuales; Hallazgos demostrados por explotación, no solo alertas - Outcomes: Vulnerabilidades validadas con PoCs reproducibles; Cobertura centrada en OWASP (inyección, XSS, SSRF, autenticación); Informes Markdown locales bajo tu control - Caveats: Ejecuta exploits reales de forma activa, solo en objetivos autorizados; El análisis de código abierto es un proceso básico de LLM en comparación con el stack más profundo de la plataforma - Cost note: CLI de código abierto gratuito (AGPL-3.0); plataforma comercial Keygraph para uso empresarial continuo. - Privacy note: Se ejecuta localmente y monta tu repositorio en solo lectura. Ejecuta exploits de forma activa; úsalo únicamente contra sistemas que te pertenezcan o para los que estés autorizado a realizar pruebas, nunca en producción. - Q: ¿Qué hace Shannon? A: Es un pentester de IA autónomo de caja blanca que lee tu código fuente para planificar ataques, luego ejecuta exploits reales contra la aplicación web en ejecución y sus APIs, e informa únicamente los hallazgos que puede demostrar con una prueba de concepto funcional. - Q: ¿Cómo lo ejecuto? A: Usa el flujo de trabajo con npx (npx @keygraph/shannon setup y luego start) con Docker y las credenciales del proveedor de IA; monta tu repositorio en solo lectura y genera un informe local. Ejecútalo únicamente contra aplicaciones que te pertenezcan o para las que estés autorizado a realizar pruebas, nunca en producción. - Q: ¿Es gratuito? A: Shannon Open Source es el CLI gratuito con licencia AGPL-3.0 que ejecutas tú mismo. La plataforma comercial Keygraph añade escaneo continuo, gestión de hallazgos, remediación automatizada y despliegue empresarial sobre el mismo motor. - **Dotmatrix** by zzzzshawn: Una biblioteca de animaciones de carga reutilizables en estilo dotmatrix para React y Next.js, instalable a través del registro de shadcn o copiando el código fuente directamente desde la documentación. - Analog: https://analoghq.ai/es/zzzzshawn/software-tools/dotmatrix - Source: https://dotmatrix.zzzzshawn.cloud/ - Install: `npm i matrix` - Repo: https://github.com/zzzzshawn/matrix - Tags: open-source, react, typescript, tailwind, shadcn, ui-components, loaders, animations - Pricing: free - Features: Animaciones de carga reutilizables en estilo dotmatrix para React y Next.js; Instalación mediante un registro estilo shadcn o copia desde la documentación; Una única app de Next.js que sirve tanto la documentación como los componentes; Registro compilado (`registry.json` y `public/r/`) para distribución; Galería de documentación en vivo; Posibilidad de publicación en el directorio del registro de shadcn - Best for: Loaders con el distintivo estilo dotmatrix; Instalaciones de componentes basadas en el registro de shadcn; Apps con React o Next.js - Outcomes: Animaciones de carga dotmatrix reutilizables; Instalación mediante registro o copia del código fuente; Una galería de documentación para previsualizar - Caveats: Estilo visual único (dotmatrix); Listar en el registro oficial requiere pasos adicionales en el directorio de shadcn - Cost note: Gratuito y de código abierto. - Q: ¿Qué es Dotmatrix? A: Una biblioteca de animaciones de carga reutilizables en estilo dotmatrix para React y Next.js, instalable a través de un registro estilo shadcn o copiando el código fuente desde la documentación. - Q: ¿Cómo añado un loader? A: Instálalo a través del registro de shadcn (la ruta principal), o copia el código fuente del componente directamente desde la documentación. - Q: ¿Dónde está la documentación? A: La galería de documentación en vivo está alojada en dotmatrix.zzzzshawn.cloud. - **Transitions.dev** by jakubantalik: Una colección interactiva de transiciones CSS reutilizables y listas para copiar: redimensionado de tarjetas, animaciones de modales y menús, aparición de insignias y más, cada una con un fragmento autocontenido que incluye una protección para movimiento reducido. - Analog: https://analoghq.ai/es/jakubantalik/software-tools/transitions-dev - Source: https://transitions.dev/ - Repo: https://github.com/Jakubantalik/transitions.dev - Tags: css, animation, ui, open-source, agent-skill, react, cli, copy-paste - Pricing: free - Features: Transiciones CSS reutilizables y listas para copiar para patrones de interfaz de usuario comunes; Fragmentos autocontenidos que usan propiedades personalizadas CSS y clases `t-*`; Protección integrada de `prefers-reduced-motion` en cada fragmento; Instalable como habilidad de agente para Cursor, Claude Code y Codex; Playground interactivo para ajustar duraciones, distancias y funciones de temporización; La habilidad se mantiene sincronizada con la exhibición mediante un paso de compilación - Best for: Añadir microinteracciones pulidas sin una biblioteca de movimiento; Copiar fragmentos CSS portátiles y seguros para movimiento reducido; Dejar que un agente aplique transiciones coherentes - Outcomes: Transiciones CSS de inserción directa para patrones de interfaz de usuario comunes; Accesible por defecto mediante una protección de movimiento reducido; Transiciones aplicadas por agente mediante una habilidad instalable - Caveats: Solo transiciones CSS, sin animaciones con muchos keyframes; Los fragmentos apuntan a patrones de interacción específicos - Cost note: Gratuito y de código abierto. - Q: ¿Cómo uso una transición? A: Copia el fragmento CSS autocontenido de una tarjeta en transitions.dev y pégalo en tu proyecto; usa clases `t-*` con espacio de nombres y propiedades personalizadas CSS, por lo que se aplica a cualquier componente sin marcado específico de la demo. - Q: ¿Puede usarlo mi agente de codificación? A: Sí. Las transiciones están empaquetadas como una habilidad de agente instalable (`npx skills add Jakubantalik/transitions.dev`) que Cursor, Claude Code y Codex pueden aplicar directamente. - Q: ¿Respeta el movimiento reducido? A: Sí. Cada fragmento incluye una protección `prefers-reduced-motion: reduce`. - **Spec Kit** by github: El kit de herramientas de código abierto de GitHub para el Desarrollo Guiado por Especificaciones. La CLI Specify convierte especificaciones ejecutables en implementaciones funcionales, con soporte para muchos agentes de codificación con IA. - Analog: https://analoghq.ai/es/github/software-tools/spec-kit - Source: https://github.com/github/spec-kit - Repo: https://github.com/github/spec-kit - Tags: open-source, cli, agent, spec-driven, ai-coding, workflow, mit-license, developer-tools - Pricing: free - Features: Kit de herramientas de GitHub para el Desarrollo Guiado por Especificaciones; La CLI Specify prepara un proyecto con especificación como punto de partida para el agente; Flujo de trabajo mediante comandos de barra: constitution, specify, plan, tasks, implement; Comandos opcionales de clarify, analyze y listas de verificación de calidad; Funciona con más de 30 agentes de codificación con IA, con un modo de habilidades; Personalizable mediante extensiones, presets y configuraciones locales - Best for: Desarrollo Guiado por Especificaciones con agentes de IA; Convertir especificaciones en implementaciones funcionales; Estandarizar un flujo de trabajo de agente en un equipo - Outcomes: Especificaciones ejecutables mediante comandos de barra; Un flujo de constitution a implement con puntos de control de calidad; Análisis cruzado de artefactos y listas de verificación - Caveats: Requiere uv para instalar la CLI Specify; La disciplina en el flujo de trabajo importa más que la herramienta - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es el Desarrollo Guiado por Especificaciones? A: Un enfoque en el que las especificaciones son ejecutables y generan directamente implementaciones funcionales, en lugar de ser andamiaje que se descarta una vez que comienza la codificación. - Q: ¿Cómo uso Spec Kit? A: Instala la CLI Specify con uv, ejecuta specify init en tu proyecto y luego usa los comandos de barra (constitution, specify, plan, tasks, implement) a través de tu agente de codificación con IA. - Q: ¿Qué agentes admite? A: Más de 30 agentes de codificación con IA, tanto de CLI como de IDE, y en el modo de habilidades puede instalar las habilidades del agente en lugar de archivos de prompts con comandos de barra. - **ping-email** by getpingback: Una biblioteca de Node.js para la verificación de correos electrónicos por SMTP, comprueba la sintaxis, los registros MX del dominio y la entregabilidad SMTP en vivo, detecta direcciones desechables y devuelve un resultado de validez estructurado. - Analog: https://analoghq.ai/es/getpingback/software-tools/ping-email - Source: https://github.com/getpingback/ping-email - Install: `npm i ping-email` - Repo: https://github.com/getpingback/ping-email - Tags: open-source, node.js, email, smtp, cli, typescript, mit-license, email-validation - Pricing: free - Features: Verificación de correo electrónico por SMTP para Node.js; Comprueba la sintaxis, los registros MX del dominio y la entregabilidad SMTP; Resultado estructurado con valid, success y un mensaje detallado; Detecta proveedores de correo desechable; Puerto, remitente, tiempo de espera, reintentos y modo de depuración configurables; Opción ignoreSMTPVerify para reducir el riesgo de bloqueo de IP; Script de CLI para filtrar un CSV y conservar solo las direcciones válidas - Best for: Validar direcciones de correo antes de enviar; Filtrar direcciones desechables o no entregables; Backends en Node.js y limpieza de CSV - Outcomes: Comprobaciones de sintaxis, MX y SMTP en una sola llamada; Un resultado estructurado con un mensaje de motivo claro; Un script de filtrado masivo de CSV - Caveats: La verificación SMTP puede hacer que bloqueen tu IP, úsala de forma responsable; Los resultados son heurísticos, no una garantía de entrega - Cost note: Gratuito y de código abierto (MIT). - Privacy note: Realiza comprobaciones SMTP en vivo contra los servidores de correo de los destinatarios, lo que puede suponer un riesgo de bloqueo de IP. Usa límite de tasa, un proxy o una IP dedicada para ejecuciones masivas. - Q: ¿Qué hace ping-email? A: Verifica direcciones de correo electrónico desde Node.js comprobando la sintaxis, los registros MX del dominio y la entregabilidad SMTP, devolviendo un resultado estructurado con validez, éxito y un mensaje detallado, además de marcar las direcciones desechables. - Q: ¿Cómo se usa? A: Instala con npm, crea una instancia de PingEmail con tus opciones SMTP (port, sender, FQDN, timeout, attempts) y llama a pingEmail.ping(address) para obtener email, valid, success y message. - Q: ¿Existe riesgo de bloqueo de IP? A: Sí. La verificación SMTP puede ser marcada como sospechosa, por lo que la biblioteca documenta mitigaciones como limitar la tasa de solicitudes, usar un proxy o una IP dedicada, y una opción ignoreSMTPVerify que omite el paso SMTP en vivo. - **Symphony** by openai: El sistema de orquestación de código abierto de OpenAI para Codex, convierte el trabajo de un proyecto en ejecuciones de implementación aisladas y autónomas para que los equipos gestionen el trabajo en lugar de supervisar agentes de codificación. - Analog: https://analoghq.ai/es/openai/software-tools/symphony - Source: https://github.com/openai/symphony - Repo: https://github.com/openai/symphony - Tags: open-source, agent, orchestration, codex, automation, elixir, apache-2.0, engineering-preview - Pricing: free - Features: Convierte el trabajo de un proyecto en ejecuciones de implementación aisladas y autónomas; Monitorea un tablero de trabajo (p. ej., Linear) y lanza agentes por tarea; Los agentes proporcionan prueba de trabajo: CI, revisión de PR, complejidad y videos; Integra los pull requests aceptados de forma segura; Se comparte como una especificación (SPEC) más una implementación de referencia en Elixir; Construye tu propia implementación a partir de la especificación en cualquier lenguaje; Vista previa de ingeniería con licencia Apache-2.0 - Best for: Gestionar el trabajo en lugar de supervisar agentes de codificación; Equipos que han adoptado la ingeniería de harness; Ejecuciones de implementación autónomas basadas en especificaciones - Outcomes: Ejecuciones de tareas autónomas dirigidas por el tablero; Prueba de trabajo antes de integrar los PRs; Una especificación que puedes reimplementar en cualquier lenguaje - Caveats: Una vista previa de ingeniería discreta para entornos de confianza; La implementación de referencia es experimental (Elixir) - Cost note: Gratuito y de código abierto (Apache-2.0). - Q: ¿Qué es Symphony? A: Un proyecto de OpenAI que convierte el trabajo en ejecuciones de implementación aisladas y autónomas, monitoreando un tablero como Linear, lanzando agentes para realizar tareas, recopilando prueba de trabajo e integrando los PRs aceptados, para que los equipos gestionen el trabajo en lugar de supervisar agentes. - Q: ¿Cómo lo ejecuto? A: Puedes apuntar tu agente de codificación al SPEC.md publicado para construir tu propia implementación en cualquier lenguaje, o configurar la implementación de referencia experimental en Elixir que se proporciona. - Q: ¿Está listo para producción? A: No. Se describe como una vista previa de ingeniería discreta destinada a pruebas en entornos de confianza, con licencia Apache 2.0. - **Metal FX** by jakubantalik: Un efecto animado de metal líquido con WebGL para React; envuelve un botón, chip o icono para darle un anillo de metal en tiempo real, con presets, tematización, intensidad ajustable y reflejo de proximidad opcional en elementos vecinos. - Analog: https://analoghq.ai/es/jakubantalik/software-tools/metal-fx - Source: https://metal.jakubantalik.com - Install: `npm i metal-fx` - Repo: https://github.com/Jakubantalik/metal-fx - Tags: react, webgl, animation, ui-component, open-source, shader, dark-mode, npm - Pricing: free - Features: Anillo de metal líquido WebGL en tiempo real para botones, chips e iconos de React; Mantiene el elemento hijo envuelto completamente interactivo; Variantes button y circle con presets chromatic, silver y gold; El tema sigue el esquema de color del sistema operativo o el estado de tu aplicación (compatible con SSR); Intensidad ajustable, modo paused y border-radius personalizado; Reflejo de proximidad en modo oscuro para elementos vecinos; Contexto WebGL compartido y un único bucle RAF para mayor eficiencia - Best for: Un acento de metal WebGL premium en botones o iconos clave; Aplicaciones React que buscan un resaltado animado y táctil; Efectos compatibles con SSR y conscientes del tema - Outcomes: Anillo de metal en tiempo real que mantiene el hijo interactivo; Presets, tematización e intensidad ajustable; Renderizado eficiente con contexto compartido - Caveats: El reflejo de proximidad es exclusivo del modo oscuro; Requiere WebGL; un contexto GL por instancia (los límites del navegador aplican) - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué es metal-fx? A: Un componente de React que pinta un anillo animado de metal líquido con WebGL alrededor de un botón, chip o icono, con presets, tematización y reflejo de proximidad, manteniendo el elemento envuelto interactivo. - Q: ¿Es eficiente con muchas instancias? A: Sí. Un único contexto WebGL compartido y un bucle `requestAnimationFrame` gestionan cada instancia, `IntersectionObserver` pausa las que están fuera de pantalla, y el contexto se libera cuando se desmonta la última instancia. - Q: ¿Es compatible con la renderización en el servidor (SSR)? A: Sí. Renderiza un marcador de posición transparente durante el SSR y solo monta el pipeline WebGL tras la hidratación, por lo que no hay ningún destello de efecto roto ni errores de SSR. - **Math Curve Loaders** by paidax01: Una galería ligera de animaciones de carga basadas en curvas matemáticas: curvas de rosa, figuras de Lissajous, hipotrocoides, cardioedes y más, construida en HTML, CSS y JavaScript puro con notas de fórmulas y código listo para copiar. - Analog: https://analoghq.ai/es/paidax01/software-tools/math-curve-loaders - Source: https://paidax01.github.io/math-curve-loaders/ - Repo: https://github.com/Paidax01/math-curve-loaders - Tags: open-source, animation, loader, css, javascript, ui, no-build, math - Pricing: free - Features: Animaciones de carga impulsadas por curvas matemáticas; Trayectorias de rosa, Lissajous, hipotrocoide, cardioede, Cassini y Fourier; Vistas previas modales con clic para abrir para cada curva; Notas de fórmulas por curva y fragmentos de código listos para copiar; HTML, CSS y JavaScript puro sin dependencias; Se ejecuta abriendo un único archivo estático en el navegador - Best for: Animaciones de carga distintivas impulsadas por matemáticas; Fragmentos ligeros y sin dependencias; Aprender parametrizaciones de curvas para la interfaz de usuario - Outcomes: Loaders listos para copiar con notas de fórmulas; Cero dependencias; Estados de carga expresivos e inusuales - Caveats: Es una galería estática, no un paquete npm; Integración por copiar y pegar en lugar de importaciones - Cost note: Gratuito y de código abierto. - Q: ¿Qué es Math Curve Loaders? A: Una galería ligera y sin dependencias de animaciones de carga basadas en curvas matemáticas (rosa, Lissajous, hipotrocoide, cardioede y más), construida con HTML, CSS y JavaScript puro. - Q: ¿Puedo reutilizar las animaciones? A: Sí. Cada curva tiene una vista previa modal con notas de fórmulas y un fragmento de código listo para copiar, para que puedas llevar la fórmula y el código a tu propio proyecto. - Q: ¿Cómo lo ejecuto? A: Abre `index.html` directamente en un navegador; no hay paso de compilación ni dependencias. - **glasscn** by kostyniuk: Una biblioteca de componentes con glassmorfismo inspirada en Apple, construida sobre shadcn/ui y Base UI, con componentes de estilo glass listos para usar (alert, button, card, calendar, popover, sidebar y más) instalables mediante el registro de shadcn. - Analog: https://analoghq.ai/es/kostyniuk/software-tools/glasscn - Source: https://glasscn-components.vercel.app - Repo: https://github.com/kostyniuk/glasscn-components - Tags: open-source, ui-components, glassmorphism, shadcn, react, nextjs, tailwind, design-system - Pricing: free - Features: Componentes con glassmorfismo construidos sobre shadcn/ui y Base UI; Se instalan por nombre mediante el registro de shadcn con el prefijo @glasscn; Las dependencias se resuelven e instalan automáticamente; Amplio conjunto de primitivas: alert, button, card, calendar, popover, sidebar y más; Prop glassVariant: estilos clear, frosted, subtle y liquid; liquid-refract usa un filtro de desplazamiento SVG para una refracción real - Best for: Añadir UI con glassmorfismo a un proyecto shadcn/ui; Instalar componentes glass mediante el registro de shadcn; Aplicaciones Next.js o React que buscan una estética de cristal esmerilado - Outcomes: Primitivas con estilo glass listas para usar; Múltiples variantes glass, incluida la refracción SVG; Dependencias resueltas automáticamente mediante el registro - Caveats: Construido específicamente sobre shadcn/ui y Base UI; liquid-refract depende de filtros de desplazamiento SVG - Cost note: Gratuito y de código abierto. - Q: ¿Qué es glasscn? A: Una biblioteca de componentes con glassmorfismo construida sobre shadcn/ui y Base UI, con versiones de estilo glass de primitivas comunes como buttons, cards, popovers, calendars y sidebars. - Q: ¿Cómo instalo un componente? A: Usa el registro de shadcn: npx shadcn add @glasscn/. Las dependencias, incluidos otros elementos del registro, se resuelven e instalan automáticamente. - Q: ¿Qué estilos glass están disponibles? A: Cada componente admite una prop glassVariant con las opciones clear, frosted, subtle y liquid, incluyendo una variante liquid-refract que usa un filtro de desplazamiento SVG para una refracción real similar a la de una lente. - **Honcho** by plastic-labs: Infraestructura de memoria para construir agentes de IA con estado, almacena mensajes y eventos, permite que Honcho razone en segundo plano y luego consulta representaciones de peers, contexto de sesión o insights en lenguaje natural desde cualquier modelo o framework. - Analog: https://analoghq.ai/es/plastic-labs/software-tools/honcho - Source: https://docs.honcho.dev - Repo: https://github.com/plastic-labs/honcho - Tags: open-source, memory, agents, stateful, rag, sdk, mcp, self-hosted - Pricing: freemium - Features: Memoria reasoning-first que extrae conclusiones, no solo fragmentos; Modelo peer-centric de usuarios, agentes, grupos y proyectos a lo largo del tiempo; Ciclo de almacenar, razonar, consultar e inyectar para cualquier LLM o framework; SDKs de Python y TypeScript con contexto listo para prompts; Búsqueda híbrida BM25-plus-vector entre peers y sesiones; Gestionado en api.honcho.dev o autoalojado mediante Docker (FastAPI); Endpoint MCP e integraciones con Claude Code, OpenCode, OpenClaw y Hermes - Best for: Dar a los agentes memoria a largo plazo por usuario; Razonar sobre conversaciones, no solo recuperación vectorial; Añadir memoria a un producto mediante el SDK o a un agente mediante MCP - Outcomes: Representaciones de peers y contexto de sesión consultables; Contexto listo para prompts para OpenAI o Anthropic; Búsqueda híbrida BM25 más vectorial - Caveats: El razonamiento en segundo plano es asíncrono; las lecturas pueden ir por detrás de las escrituras; La licencia AGPL-3.0 tiene implicaciones para el uso en código cerrado - Cost note: Código abierto (AGPL-3.0). Gestionado en api.honcho.dev con créditos iniciales gratuitos, o autoalojado. - Privacy note: Aloja tú mismo el servidor FastAPI para mantener la memoria en tu propia infraestructura; la opción gestionada la almacena con Plastic Labs. - Q: ¿Qué es Honcho? A: Infraestructura de memoria para agentes con estado: almacenas mensajes y eventos, Honcho razona sobre ellos en segundo plano para construir una representación por peer, y tú consultas esa representación para obtener contexto o insights en lenguaje natural. - Q: ¿Gestionado o autoalojado? A: Ambos. Usa el servicio gestionado en api.honcho.dev con créditos iniciales, o aloja tú mismo el servidor FastAPI con Docker. - Q: ¿Cómo se integra con agentes de codificación? A: Proporciona un endpoint MCP directo para cualquier cliente MCP, además de integraciones dedicadas para Claude Code, OpenCode, OpenClaw y Hermes, y una habilidad de agente que conecta el SDK a tu propia base de código. - **Kodus** by kodustech: Revisión de código con IA de código abierto, con control total sobre la elección del modelo y los costos. Se ejecuta en tus pull requests en GitHub, GitLab, Bitbucket y Azure, con reglas personalizadas en lenguaje natural y opciones de alojamiento propio o en la nube. - Analog: https://analoghq.ai/es/kodustech/software-tools/kodus - Source: https://kodus.io - Repo: https://github.com/kodustech/kodus-ai - Tags: open-source, code-review, ai, cli, self-hosted, pull-request, agplv3, devtools - Pricing: freemium - Features: Revisión de código con IA que se ejecuta directamente en tus pull requests; Agnóstico al modelo con bring-your-own-key y sin margen de costo adicional; Reglas de revisión personalizadas definidas en lenguaje natural; Compatible con GitHub, GitLab, Bitbucket y Azure Repos; CLI para ejecuciones locales y pipelines de CI/CD; Autoalojable con cifrado en tránsito y en reposo; Edición Community gratuita más niveles de pago Teams y Enterprise - Best for: Revisión de código con IA con control sobre los modelos y el costo; Equipos en GitHub, GitLab, Bitbucket o Azure Repos; Autoalojar un agente de revisión de código abierto - Outcomes: Revisiones con contexto en tus PRs; Sin margen sobre el gasto en LLM (aporta tu propia clave); Reglas de revisión personalizadas en lenguaje natural - Caveats: El autoalojamiento requiere infraestructura (Docker, Railway o una VM); Se necesita ajuste de reglas para obtener la mejor señal - Cost note: Edición Community de código abierto gratuita (autoalojada o en la nube); niveles de pago Teams (~$10/dev/mes) y Enterprise. - Privacy note: El código fuente no se usa para entrenar modelos; cifrado en tránsito y en reposo; se admiten ejecutores autoalojados; la telemetría es opt-out. - Q: ¿Qué modelos puede usar Kodus? A: Es agnóstico al modelo, ya sea Claude, GPT, Gemini, Llama, GLM, Kimi o cualquier endpoint compatible con OpenAI, y tú aportas tu propia clave y pagas a los proveedores directamente sin ningún margen adicional. - Q: ¿Puedo autoalojarlo? A: Sí. La edición Community gratuita puede autoalojarse o ser alojada por Kodus, con PRs ilimitados usando tu propia clave de API; los niveles de pago Teams y Enterprise añaden métricas, SSO, RBAC y SOC 2. - Q: ¿Dónde ejecuta las revisiones? A: Directamente en pull requests de GitHub, GitLab, Bitbucket y Azure Repos, y de forma local o en CI/CD mediante su CLI. - **Open Design** by nexu-io: Aplicación de escritorio local-first y de código abierto para diseño agéntico; genera y edita interfaces web, móviles y prototipos de UI, presentaciones, imágenes y video, con enrutamiento bring-your-own-key entre los principales LLMs. - Analog: https://analoghq.ai/es/nexu-io/software-tools/open-design - Source: https://open-design.ai - Repo: https://github.com/nexu-io/open-design - Tags: open-source, local-first, agent-native, design, byok, mcp, desktop, self-hosted - Pricing: free - Features: Aplicación de escritorio local-first y de código abierto para macOS y Windows; Convierte un contrato de marca DESIGN.md en prototipos, presentaciones, imágenes y video; Exporta a HTML, PDF, PPTX y MP4 desde una vista previa en sandbox; Se distribuye como skills, una CLI y un servidor MCP con instalación de agente en una sola línea; Compatible con Claude Code, Codex, Cursor, Copilot, Gemini y más; Proxy bring-your-own-key para cualquier endpoint compatible con OpenAI; Biblioteca incluida de más de 100 skills, 150 sistemas de diseño y 261 plugins - Best for: Generar UI, presentaciones y contenido multimedia coherentes con la marca a partir de un DESIGN.md; Diseñadores que buscan un flujo de trabajo local-first y nativo de agentes; Impulsar el diseño desde un agente de codificación existente mediante MCP - Outcomes: Prototipos, presentaciones, imágenes y video moldeados por tu sistema de diseño; Flujo de trabajo en una sola ventana, desde el brief hasta la exportación; Usa tus propias claves de modelo o un enrutador hospedado - Caveats: Aplicación de escritorio solo para macOS y Windows; Posicionamiento con mucho énfasis en marketing; evalúa según tus propias necesidades - Cost note: La aplicación es gratuita y de código abierto (Apache-2.0). Enrutador de modelos de pago opcional (AMR), o usa tus propias claves. - Privacy note: Aplicación de escritorio local-first; con bring-your-own-key, el tráfico de modelos va a tu proveedor elegido. Protección SSRF por destino en el proxy. - Q: ¿Es gratuito Open Design? A: La aplicación es gratuita y de código abierto bajo Apache-2.0, y se ejecuta en local. Un enrutador de modelos de pago opcional (AMR) ofrece acceso hospedado a varios modelos de última generación, pero también puedes usar tus propias claves de API. - Q: ¿Cómo encaja con mi agente de codificación existente? A: Se instala como un servidor MCP con un solo comando (`od mcp install `) para Claude Code, Codex, Cursor, Copilot, Gemini, OpenCode y otros, de modo que puedes invocar sus herramientas desde el agente que ya utilizas. - Q: ¿Qué puede producir? A: Prototipos de una sola página, paneles de control y artefactos en vivo, pitch decks, imágenes de calidad de marca y gráficos en movimiento HyperFrame, todo moldeado por tu sistema de diseño y exportable a HTML, PDF, PPTX o MP4. - **Anatomia** by anatomia-dev: Un harness de agente basado en CLI y especificaciones para Claude Code y Codex: analiza tu base de código y ejecuta cada cambio a través de un pipeline de cinco agentes (scope, plan, build, verify, learn) con una cadena de pruebas auditable. - Analog: https://analoghq.ai/es/anatomia-dev/software-tools/anatomia - Source: https://anatomia.dev - Install: `npm i anatomia` - Repo: https://github.com/anatomia-dev/anatomia - Tags: cli, agent, open-source, mit, verification, pipeline, code-quality, developer-tools - Pricing: freemium - Features: Analiza tu stack, convenciones y patrones en segundos; Escribe contexto legible por agentes: ana.json, CLAUDE.md, AGENTS.md y habilidades; Pipeline de cinco etapas: Think, Plan, Build, Verify, Learn; Etapa de verificación independiente que ignora el informe del constructor; Entradas de cadena de pruebas con un panel de trayectoria de calidad; Valida y genera un hash de contenido por cada artefacto que producen los agentes; Soporte nativo para Claude Code y Codex - Best for: Incorporar estructura y verificación al desarrollo con agentes; Presentar agentes a una base de código desconocida; Equipos que necesitan una cadena de pruebas auditable por cambio - Outcomes: Archivos de contexto generados por análisis que los agentes realmente leen; Cada cambio delimitado, planificado, construido y verificado de forma independiente; Una cadena de pruebas que rastrea la calidad a lo largo del tiempo - Caveats: El pipeline requiere Claude Code o Codex; Requiere Node.js 22 o superior - Cost note: Gratuito y de código abierto (MIT). - Privacy note: Se ejecuta localmente a través de tu propio agente; nunca modifica el código fuente fuera del trabajo en sí. - Q: ¿Qué diferencia a Anatomia de una biblioteca de prompts? A: Incluye un motor: un CLI que analiza tu proyecto, ejecuta cada cambio a través de un pipeline de cinco etapas y valida cada artefacto que producen los agentes, en lugar de limitarse a proporcionar instrucciones. - Q: ¿Con qué agentes funciona? A: Tiene soporte nativo de pipeline para Claude Code y Codex, y su salida de análisis (AGENTS.md, CLAUDE.md) funciona con cualquier herramienta de IA que reconozca Markdown. - Q: ¿Qué es la cadena de pruebas? A: Cada ejecución del pipeline registra una entrada auditable de lo que fue delimitado, planificado, construido y verificado; los comandos de prueba rastrean las tasas de verificación en el primer intento, los riesgos y los puntos críticos, y pueden promover hallazgos recurrentes a reglas de habilidades. - **Square UI** by ln-dev7: Una colección de layouts de interfaz de usuario de código abierto, cuidadosamente elaborados con Next.js y shadcn/ui: dashboards, rastreadores y plantillas de aplicaciones con demos en vivo, en variantes tanto de Radix UI como de Base UI. - Analog: https://analoghq.ai/es/ln-dev7/software-tools/square-ui - Source: https://square.lndev.me - Repo: https://github.com/ln-dev7/square-ui - Tags: open-source, ui, templates, next.js, shadcn, tailwind, typescript, dashboard - Pricing: freemium - Features: Layouts de aplicaciones de código abierto construidos con Next.js y shadcn/ui; Interfaces completas y realistas en lugar de componentes aislados; Dashboards, rastreadores, gestores de archivos, calendarios y más; Cada plantilla incluye una demo en vivo; Variantes de cada plantilla en Radix UI y Base UI; Construido con Next.js, TypeScript, shadcn/ui y Tailwind CSS - Best for: Comenzar una interfaz de aplicación a partir de un layout completo y realista; Proyectos con shadcn/ui sobre Next.js; Elegir entre las variantes Radix UI y Base UI - Outcomes: Dashboards y pantallas de aplicación con aspecto de producción de forma rápida; Demos en vivo para evaluar antes de adoptar; Elige el primitivo que prefieras: Radix UI o Base UI - Caveats: Son plantillas, no una biblioteca de componentes empaquetada; Orientado al stack de shadcn/ui y Next.js - Cost note: La colección principal es gratuita y de código abierto; hay un nivel premium, Square UI Pro, disponible. - Q: ¿Qué es Square UI? A: Una colección de código abierto de layouts de aplicaciones completos y cuidados (dashboards, rastreadores, gestores y más) construidos con Next.js y shadcn/ui, cada uno con una demo en vivo. - Q: ¿Es compatible con Base UI además de Radix? A: Sí. Cada plantilla viene en dos variantes: una construida sobre Radix UI y otra sobre Base UI, para que puedas ajustarte al primitivo de tu proyecto. - Q: ¿Es gratuito? A: La colección principal es gratuita y de código abierto. Un nivel premium, Square UI Pro, ofrece plantillas adicionales. - **Kiira** by alemtuzlak: Verifica los tipos del código TypeScript y JavaScript en tus documentos Markdown y MDX contra la API real de tu proyecto, en tu editor, la CLI y CI, para que los ejemplos documentados nunca queden desactualizados ni sean alucinados. - Analog: https://analoghq.ai/es/alemtuzlak/software-tools/kiira - Source: https://github.com/AlemTuzlak/kiira - Install: `npx kiira` - Repo: https://github.com/AlemTuzlak/kiira - Tags: cli, open-source, typescript, documentation, dx, ci, vscode, monorepo - Pricing: free - Features: Verifica los tipos de los bloques de código TS y JS en Markdown y MDX contra la API real de tu proyecto.; Reporta errores de forma integrada en tu editor, la CLI y CI.; Resolución de monorepo con workspace awareness sin rutas tsconfig escritas a mano.; Sobreescrituras de compilador por glob para documentación multisistema.; Agrupación de fragmentos para tutoriales de múltiples bloques.; Modo de corrección automática que reescribe bloques mal etiquetados y añade etiquetas de agrupación.; Se distribuye como biblioteca central, CLI, extensión de VS Code y GitHub Action. - Best for: Mantener los ejemplos de código en los documentos con tipos correctos.; Mantenedores de bibliotecas y frameworks con documentación repleta de ejemplos.; Equipos cuya documentación es escrita o actualizada por agentes de IA. - Outcomes: Las importaciones rotas y las APIs incorrectas en los documentos se detectan antes de publicar.; Los ejemplos se mantienen sincronizados con los tipos reales de tu proyecto.; CI falla cuando un fragmento documentado no compilaría. - Caveats: Solo verifica tipos en bloques JS/TS; otros lenguajes son ignorados.; Necesita un tsconfig y las dependencias reales del proyecto para resolver importaciones. - Cost note: Gratuito y de código abierto (MIT). - Q: ¿Qué problema resuelve Kiira? A: Mantiene correctos los ejemplos de código en tu documentación verificando sus tipos contra la API real de tu proyecto, para que las importaciones, exportaciones y nombres de opciones no puedan quedar desactualizados en silencio ni ser alucinados por un agente de IA. - Q: ¿Dónde puede ejecutarse Kiira? A: En tu editor (una extensión de VS Code muestra subrayados en tiempo real dentro de los bloques Markdown), en la línea de comandos mediante kiira check, y en CI a través de la GitHub Action incluida. - Q: ¿Funciona Kiira en monorepos? A: Sí. En modo workspace descubre tu workspace de pnpm, npm o yarn y mapea cada paquete a su fuente, de modo que los documentos que importan tus paquetes internos y bibliotecas de terceros se resuelven sin rutas tsconfig escritas a mano. - **Better Upload** by nic13gamer: Subida de archivos sencilla para React; sube directamente a cualquier almacenamiento compatible con S3 con una configuración mínima. Compatible con Next.js, TanStack Start y cualquier framework de React. - Analog: https://analoghq.ai/es/nic13gamer/software-tools/better-upload - Source: https://better-upload.com - Install: `npm i better-upload` - Repo: https://github.com/Nic13Gamer/better-upload - Tags: react, typescript, open-source, s3, file-upload, nextjs, presigned-url, shadcn - Pricing: free - Features: Subidas directas a cualquier servicio de almacenamiento compatible con S3; Configuración mínima, añade subidas en pocos minutos; Compatible con Next.js, TanStack Start y cualquier framework de React; Mantiene los bytes de los archivos fuera de tu propio servidor; Guía quickstart documentada; Licencia MIT y código abierto - Best for: Añadir subidas compatibles con S3 a una aplicación React rápidamente; Mantener los bytes de archivos grandes fuera de tu propio servidor; Proyectos con Next.js o TanStack Start - Outcomes: Subidas directas al almacenamiento con configuración mínima; Menor carga y ancho de banda en el servidor; Compatible con frameworks de React - Caveats: Solo para React; Tú suministras y configuras el bucket de almacenamiento - Cost note: Gratuito y de código abierto (MIT). - Privacy note: Las subidas van directamente a tu propio bucket compatible con S3; ningún servicio de terceros interviene en el proceso. - Q: ¿Qué es Better Upload? A: Una biblioteca ligera para añadir subida de archivos a aplicaciones React que envía los archivos directamente a cualquier servicio de almacenamiento compatible con S3 con una configuración mínima. - Q: ¿Qué frameworks admite? A: Cualquier framework basado en React, incluidos Next.js y TanStack Start. - Q: ¿A dónde se suben los archivos? A: Directamente a cualquier servicio compatible con S3, de modo que la subida no tiene que pasar por tu propio servidor. - **SkillSpector** by nvidia: Un escáner de seguridad de código abierto para skills de agentes de IA que detecta vulnerabilidades, patrones maliciosos y riesgos en la cadena de suministro a través de 64 patrones antes de instalar una skill, con análisis estático y evaluación semántica opcional mediante LLM. - Analog: https://analoghq.ai/es/nvidia/software-tools/skillspector - Source: https://github.com/NVIDIA/SkillSpector - Install: `git clone https://github.com/NVIDIA/SkillSpector.git cd SkillSpector uv venv .venv && source .venv/bin/activate make install skillspector scan ./my-skill/` - Repo: https://github.com/NVIDIA/SkillSpector - Tags: security, open-source, cli, mcp, agent, nvidia, static-analysis, python - Pricing: free - Features: Analiza skills de agentes de IA en busca de vulnerabilidades antes de instalarlas; 64 patrones de vulnerabilidad en 16 categorías; Análisis en dos etapas: estático rápido más evaluación opcional mediante LLM; Consultas de CVE en tiempo real contra OSV.dev para dependencias vulnerables; Acepta repositorios Git, URLs, archivos zip, directorios o archivos individuales; Genera salida en terminal, JSON, Markdown o SARIF con una puntuación de riesgo de 0 a 100; Se ejecuta mediante pip, uv o Docker; licencia Apache-2.0 - Best for: Verificar una skill de agente de IA antes de instalarla; Agregar comprobaciones de seguridad de skills a CI mediante SARIF; Auditar skills en busca de inyección de prompts y exfiltración - Outcomes: Una puntuación de riesgo de 0 a 100 con severidad y recomendaciones; Análisis estático más evaluación opcional mediante LLM sobre 64 patrones; Informes en SARIF, JSON o Markdown listos para CI e IDE - Caveats: El alcance son las skills de agentes, no código fuente arbitrario; Detección heurística: revisa los hallazgos y espera algunos falsos positivos - Cost note: Gratuito y de código abierto (Apache-2.0); el análisis mediante LLM utiliza tu propia clave de proveedor. - Privacy note: Se ejecuta de forma local; el modo estático (--no-llm) no envía nada al exterior. El modo LLM envía contenido al proveedor que elijas. - Q: ¿Qué verifica SkillSpector? A: 64 patrones de vulnerabilidad en 16 categorías, incluyendo inyección de prompts, exfiltración de datos, escalada de privilegios, riesgos en la cadena de suministro con consultas de CVE en tiempo real, agencia excesiva, envenenamiento de memoria y envenenamiento de herramientas MCP. - Q: ¿Necesito una clave de API de LLM para usarlo? A: No. Ejecuta análisis estático rápido con --no-llm y, opcionalmente, agrega evaluación semántica mediante LLM si configuras un endpoint de OpenAI, Anthropic, NVIDIA o uno local compatible con OpenAI. - Q: ¿Cómo lo ejecuto? A: Instálalo mediante pip o uv, o usa la imagen Docker, luego ejecuta skillspector scan contra un directorio, un archivo SKILL.md, una URL de Git o un zip. Los formatos de salida incluyen terminal, JSON, Markdown y SARIF. --- ## Artículos Articles on Analog are the long-form reading worth your time — in-depth guides, tutorials, playbooks, and startup resources for building with AI. From hands-on how-tos and concept explainers to field reports from people shipping with agents and resources for AI founders, these are the pieces that actually teach. Browse the community's picks, ranked for signal over noise, and filter to guides, playbooks, or startup resources. This topic gathers the in-depth writing on building with AI: step-by-step tutorials, architecture and concept explainers, repeatable playbooks from practitioners, and the tools, templates, and reading that help founders build an AI startup. Unlike a quick blog post, these are the references you bookmark and come back to — the ones that change how you work rather than just informing you. Authorship spans the community — individual engineers, teams, vendors, and founders — and quality, not source, is what earns a place here. Use the filters to narrow to guides, playbooks, or startup resources, and follow each entry's link to read it where the author published it. Startup resources pair well with the credits and discounts on the Deals page. Upvotes surface the pieces people recommend to others. ### FAQ: Artículos **What's in the Articles topic?** Long-form reading for building with AI: guides and tutorials, concept explainers, practitioner playbooks, and startup resources for founders. Use the Guides, Playbooks, and Startup filters to narrow the list to what you need. **Who writes these articles?** They're authored across the community — individual practitioners, teams, vendors, and founders. Analog curates for quality and accuracy and links to the original source rather than republishing it. **What's the difference between a guide and a playbook?** A guide teaches a concept or walks through a how-to; a playbook is a repeatable process you run — the steps, prompts, and checks that reliably get a job done. Both live here, each under its own filter. **Where can I find startup credits and discounts?** On Analog's Deals page, which lists verified cloud and AI credits, discounts, and perks for builders — with the eligibility spelled out. Many pair well with the startup resources in this topic. **Are the articles free to read?** Most are freely readable. Follow each entry's link to the source for the full piece; a few may sit behind a sign-up or paywall, which we note where we can. **How are articles ranked on Analog?** By community upvotes, one per account, with new additions under the New tab. Every article is human-reviewed before it appears. ### Entries in Artículos (ranked) - **How to make Claude time-travel and tell you how your plan dies** by itsolelehmann: How to turn Claude into a structured adversary by assuming your plan already failed, and a ready-to-upload skill that automates the pre-mortem for any decision. - Analog: https://analoghq.ai/es/itsolelehmann/articles/claude-pre-mortem-skill - Source: https://x.com/itsolelehmann/status/2051373618727469152 - Tags: claude, prompt-engineering, decision-making, pre-mortem, productivity, ai-workflow - Best for: Builders who need adversarial critique before committing budget or time to a plan; Teams running product launches, fundraises, hires, strategy decisions, or investments; Anyone who suspects Claude is just validating their ideas instead of stress-testing them - Outcomes: A reframed prompt structure that forces Claude out of sycophantic validation mode into adversarial analysis; Specific failure modes scored by likelihood and severity, plus the single hidden assumption the team treated as settled; A revised plan with assigned owners, early-warning metrics, and explicit kill criteria; A reusable SKILL.md file uploadable once that applies the pre-mortem technique to any future decision - Caveats: Output quality is strictly bounded by input quality, a vague plan produces a vague autopsy; Does not fix sycophancy at the model level, it sidesteps it by reframing the prompt tense; Technique relies on prospective hindsight research but the 30% improvement figure is from a 1989 study, not Claude-specific benchmarking - Q: What is a pre-mortem and how does it differ from a normal risk review? A: A pre-mortem assumes the plan has already failed, then works backward to explain how it died. Unlike a standard risk review that asks 'what could go wrong?', the past-tense framing triggers prospective hindsight: research from Gary Klein (1989) shows this makes people roughly 30% better at identifying the actual reasons for failure. The cognitive shift matters because it bypasses the emotional investment teams have in plans they've already started building. - Q: How do I actually use this Claude skill? A: You upload a single SKILL.md file to Claude, after which Claude is available as a structured adversarial auditor on demand. You feed it your plan, and it reconstructs the context, generates ranked failure modes by likelihood and severity, identifies the hidden assumption everyone treated as settled, and returns a revised plan with owners, early-warning metrics, and kill criteria. The article says the full cycle runs in about 60 seconds from a well-formed input. - Q: Is this article free to read? A: The full Linas Beliūnas piece on Substack is marked as paid content, requiring a subscription to access the complete SKILL.md file and all five worked playbooks. The aisolo.beehiiv.com and generativeai.pub versions are separately available and cover the core technique, the cognitive science behind it, and practical prompt framing without a paywall. - Q: What decisions is the pre-mortem skill most useful for? A: The article identifies five primary playbooks: product launches, fundraising rounds, hiring decisions, strategy pivots, and investments. The common thread is irreversibility or high cost, decisions where optimism bias is most dangerous because you cannot easily unwind them. The technique is less necessary for low-stakes, easily reversible choices where moving fast outweighs the cost of a wrong turn. - Q: How does this address Claude's sycophancy problem specifically? A: Claude's RLHF training causes it to prefer agreeable responses, especially when a user signals ownership by presenting their own plan. Asking 'is this good?' reliably produces validation with cosmetic caveats. The pre-mortem prompt sidesteps this entirely by not asking for a verdict: instead it gives Claude a fact ('the plan failed') and asks for a causal narrative, which is a task Claude can perform without the sycophantic pull. Anthropic, OpenAI, and Meta have all documented this sycophancy behavior in their own research. - Q: What makes the difference between a useful pre-mortem and a useless one? A: The article's 'weak input vs. strong input' rule is the key variable: a vague plan description produces a vague failure analysis that won't change any decision. The skill works best when the input is specific enough that Claude can reconstruct the plan's real assumptions, timelines, and constraints. The article includes a real worked example of a launch being torn apart and rebuilt, which illustrates concretely what a high-quality input and output look like. - **I Searched the Whole Claude Skills Ecosystem - These Are the Ones That Matter** by polydao: A curated breakdown of the Claude skills ecosystem, what skills are, how they work, and the handful worth installing first. - Analog: https://analoghq.ai/es/polydao/articles/claude-skills-ecosystem-ones-that-matter - Source: https://x.com/polydao/status/2060715587387400424 - Tags: claude, prompt-engineering, automation, knowledge-worker, open-source, anthropic, workflow - Best for: Knowledge workers who need reliable document format conversions, such as PDF, DOCX, PPTX, and XLSX, on a daily basis; Builders who want composable, multi-step workflows that a single static system prompt cannot replicate; Users who prefer a small, intentional stack over a bloated library of overlapping or untested skills; Teams starting with Claude skills who want a well-maintained baseline from Anthropic's own GitHub repository - Outcomes: A starter stack of six Anthropic-maintained skills covering document formats and the Claude API, with predictable behavior; Reduced context-window overhead, since only a skill's short description loads at all times and full instructions load on demand; Ability to chain skills into multi-step workflows triggered automatically by intent or manually via /skill_name; A repeatable habit of reading SKILL.md execution instructions before enabling any community skill, reducing unexpected output - Caveats: Community skills with vague descriptions can silently match unintended queries and load unreviewed instructions; The catalog has crossed 1.5 million entries but the vast majority target coders, leaving knowledge worker coverage thin; A skill's quality is often invisible at install time, making pre-install review of the full SKILL.md a required discipline; Indiscriminate installation bloats context even with lazy loading, since all skill descriptions load into active context always - Q: What exactly is a Claude skill? A: A Claude skill is a SKILL.md markdown file with two parts: a short description and a set of execution instructions. Per the How-To Geek review, only descriptions are loaded into Claude's active context window at startup; the full instructions are pulled in dynamically only when Claude matches a skill to your request, or when you manually trigger it with /skill_name. This architecture means you can maintain a large library of skills without the context-window cost of running all their instructions simultaneously. Skills can also be chained together, enabling multi-step workflows that a single static system prompt cannot replicate. - Q: How do I install a Claude skill? A: To install a skill, download the SKILL.md file from a source such as Anthropic's own GitHub repository at github.com/anthropics/skills, then open Claude and navigate to the Customize section in the left-hand sidebar. From there, click Create New Skill, hit the + button, select Create Skill, and choose Upload a Skill to upload the MD file. Once installed, Claude will load the skill's description into context and invoke the full instructions whenever it detects a matching request. You can also trigger any skill manually by typing /skill_name in the chat. - Q: Are Claude skills free, and where do they come from? A: The skills themselves are free to install: they are open SKILL.md files hosted on GitHub, most prominently in Anthropic's own public repository at github.com/anthropics/skills. Accessing the full catalog and installing skills does require a Claude subscription; How-To Geek notes that Claude is priced at $20 per month for the Pro tier. The ecosystem is open, so anyone can publish a skill, which is both its strength and the reason manual vetting of community skills is necessary before enabling them. - Q: What is the best starting stack for a knowledge worker? A: The safest and most useful starting stack, drawn from both the How-To Geek review and the Emerging AI breakdown, is Anthropic's own document skills: PDF, DOCX, PPTX, and XLSX, all available at github.com/anthropics/skills. Adding the Claude API skill and the Skill Creator skill rounds out a core six-skill pack that covers document handling, API-pattern work, and the ability to turn your own workflows into reusable skills. This stack is well-maintained, predictable, and avoids the quality variance of the broader community catalog. Most community skills skew toward coding use cases and require extra filtering before they become useful for general knowledge work. - Q: How does the skills approach compare to just using Claude Projects with custom instructions? A: Claude Projects with custom instructions load the full instruction text into context for every conversation, which is simple but expensive on the context window when you have many instructions. Skills differ because only their short descriptions are resident in context; the full instructions load on demand, per the How-To Geek explanation of the dynamic loading mechanic. This makes skills better suited to carrying a diverse library of capabilities across varied tasks, while Projects remain the right choice when you want a fixed, always-on persona or ruleset for a specific recurring workflow. The two approaches are complementary: you might use a Project for a stable context and layer skills i - Q: What are the main limitations or risks of the skills ecosystem? A: The ecosystem's biggest risk is its openness: with over 1.5 million catalog entries, the quality variance is enormous, and a poorly written community skill can trigger unexpectedly or produce output you did not intend. The How-To Geek review found that the majority of top-rated skills are narrowly focused on coding, leaving knowledge workers to do significant filtering work. The practical mitigation is to always read a skill's full execution instructions in the SKILL.md file before enabling it, and to start with Anthropic's maintained packs rather than random community entries. There is no automated quality gate, so the burden of vetting falls entirely on the user. - **a color system that disappears** by msllrs: Explores the cultural fade of color in products alongside nanoscale methods that make material color disappear through structural interference. - Analog: https://analoghq.ai/es/msllrs/articles/a-color-system-that-disappears - Source: https://x.com/msllrs/status/2067186699701002607 - Tags: color, design, minimalism, nanotech, structural-color, optics - Best for: Designers choosing palettes for products or interfaces; Engineers exploring nanophotonics or optical components; Readers tracing how cultural minimalism shapes everyday objects - Outcomes: Clear view of the 1900-present graying trend across industries; Concrete nanoscale example of structural color overriding intrinsic color; Tradeoffs between visual restraint and engineered optical effects - Q: What is the main claim of the article? A: The article claims that color is disappearing from consumer products due to cultural preferences for minimalism and efficiency, while researchers have also engineered nanoscale structures that physically eliminate a material's intrinsic color through structural interference. - Q: How does the nanoscale system remove color? A: Researchers arranged tungsten disulfide strips a few dozen atoms thick on a gold backing at sub-optical wavelengths. When dimensions are tuned correctly, the resulting structural color interactions cancel the semiconductor's natural absorption of orange light, leaving the surface with no visible color of its own. - Q: What evidence shows the world is losing color? A: A Science Museum Group analysis of over 7,000 object photographs found palettes growing grayer after 1900. Auto industry reports and Apple product lines confirm the dominance of white, black, gray, and neutral tones in cars and electronics. - Q: Who should read this article? A: Designers selecting interface or product palettes and engineers working on optics or hardware will gain the clearest takeaways. The piece connects a broad cultural trend to a specific physics demonstration. - Q: What practical implications does the research carry? A: The ability to make materials appear colorless through structure alone points toward holographic displays, optical sensors, microlasers, and components for photonic computers. It gives engineers a new lever beyond chemical pigments. - Q: What limits or open questions remain? A: The cultural shift toward neutral colors is presented as an observed trend without a single proven cause. The nanoscale work is still at the experimental stage and requires precise fabrication that may not yet scale to everyday products. - **Loops explained: Claude, GPT, Mira and what actually works** by anatolikopadze: A viral breakdown of AI agent loops, how Claude, ChatGPT, and Mira implement Plan-Execute-Verify cycles and when to actually build one. - Analog: https://analoghq.ai/es/anatolikopadze/articles/loops-explained-claude-gpt-mira - Source: https://x.com/AnatoliKopadze/status/2068328135611822149 - Tags: agent, loops, claude, chatgpt, mira, automation, prompt-engineering, agentic - Best for: Builders who run the same AI task weekly or more and want compounding results instead of one-shot prompts; Teams where failure has real cost and iteration stakes justify the setup overhead; Developers ready to move from prompt-and-close habits to structured Plan-Execute-Verify-Iterate cycles; Engineers evaluating Claude Code, ChatGPT, or Mira for agentic or recurring workflow use cases - Outcomes: A concrete five-stage loop blueprint: DISCOVER, PLAN, EXECUTE, VERIFY, ITERATE, mapped to real tools; A four-box diagnostic test to decide whether a loop is worth building before writing a single line; A tiered tool map: Mira for no-code recurring tasks, ChatGPT self-check prompts for mid complexity, Claude Code for high complexity agentic work; Understanding of three failure modes builders most commonly hit: missing verify gate, missing state, and missing stop condition; Framework evidence that a weaker model in a loop can outperform a stronger model on a single shot, per Andrew Ng finding cited - Caveats: Auto-verification is the box most builders fail first: describing a goal is not the same as having a hard measurable condition; Without a stop condition the article explicitly warns of a runaway loop that runs until it breaks or exhausts your token budget; The article is framed around a single X post and LinkedIn summary, so cited findings are secondhand rather than primary sourced; Mira Telegram Skills coverage is thin, positioned only as an entry point with minimal detail on capabilities or limits - Q: What is an AI agent loop and how is it different from a regular prompt? A: An AI agent loop is a repeatable, structured cycle in which the model receives a goal, produces output, evaluates that output against a defined condition, and feeds the result back into the next run. A single prompt is a one-shot exchange with no feedback path. The article defines the cycle as five stages: DISCOVER, PLAN, EXECUTE, VERIFY, and ITERATE, and argues the VERIFY stage is what makes it a loop rather than a model agreeing with itself repeatedly. - Q: What are the three components builders most often get wrong in a loop? A: The article identifies the verify gate, state, and stop condition as the three most commonly missing pieces. The verify gate is a hard, measurable condition (or scored rubric) the output must pass, not a vague 'does it feel right' check. State is a persistent record of what was tried and what failed, so the loop does not restart from zero each session. The stop condition is an explicit success threshold plus a hard iteration or token cap to prevent runaway execution. - Q: When should I NOT build a loop, and just write a better prompt instead? A: The article prescribes a four-box test: a loop is worth building only when the task repeats at least weekly, the output is auto-verifiable by the agent (not just by a human), failure has a real cost that makes iteration worthwhile, and you have a state store to carry context across runs. If any one of the four conditions fails, a well-written single prompt is cheaper and faster. The box most builders fail first is auto-verification: they can state the goal but cannot write a condition the agent can evaluate without human review. - Q: Which tool should I start with: Mira, ChatGPT, or Claude Code? A: The article maps the three tools to explicit complexity tiers. Start with Mira Telegram Skills (low tier) to validate the loop pattern with minimal setup and no code. Move to ChatGPT self-check prompts (mid tier) when you need a measurable scoring rubric, such as 'score this output 1-5 against the criterion: does it address the specific objection a skeptical CFO would raise?' and iterate until a threshold is met. Reach for Claude Code /goal and /loop (high tier) when the task requires external tool use, file state, and multi-step autonomous planning. - Q: What evidence does the article give that loops outperform single-shot prompting? A: The article cites AI pioneer Andrew Ng's finding that wrapping an LLM in an iterative Plan-Act-Reflect loop can make a weaker model outperform a stronger model running on a single shot. It also references Andrej Karpathy's AutoResearch project as a frontier production example, where an autonomous agent edits code, runs GPU experiments, checks metrics, and commits or rolls back changes overnight without human intervention. Both are cited by name in the LinkedIn summary by Cyril Gupta, though without direct links to the primary sources. - Q: What is the 'Ralph Wiggum loop' and how do I avoid it? A: The article uses 'Ralph Wiggum loop' as a label for a loop that runs without a proper stop condition, continuing until it either succeeds by accident, encounters an error, or exhausts your token or API budget. The fix is to define two explicit stop conditions before you deploy: a success criterion the verify gate can actually measure, and a hard cap on the number of iterations or tokens the loop is allowed to consume. Without both, an unchecked loop is a financial and operational risk, not a productivity tool. - **Why Your Claude Skill Sits Unused (And How to Make It Fire)** by nurijanian: A Claude skill is a folder of instructions that teaches Claude your team's way of doing a recurring task. Most are easy to build but quietly fail because Claude never reaches for them or the output is wrong. This guide shows you the few habits and the one testing loop that fix that. - Analog: https://analoghq.ai/es/nurijanian/articles/build-once-reuse-forever-make-claude-follow-your - Source: https://x.com/nurijanian/status/2060672098050490380 - Tags: claude, ai-skills, product-management, prompting, ai-tools, beginners, automation - Q: What exactly is a Claude skill? A: A Claude skill is a folder that teaches Claude how to do a recurring task your way. At minimum it holds one file, SKILL.md, written in plain Markdown, that opens with a name and description and then lists your instructions. Anthropic frames it as an onboarding guide for a new hire: Claude can already reason, but it cannot guess your house rules, like how your team formats a product spec. The skill hands Claude that knowledge so you stop re-explaining yourself every session. - Q: Why does my skill never get used even though it works? A: Almost always the description is too vague. The description is the only part of your skill Claude reads when it decides whether to reach for it, so if it says something like 'Helps with documents,' Claude has no idea when to use it. Anthropic recommends writing the description in third person, naming what the skill does, and naming the triggers, the actual words a user would say. 'Processes Excel files and generates reports' fires reliably where a fuzzy line stays unused. - Q: Do I need to be a programmer to build one? A: You do not need to be a programmer. A working skill can be nothing more than a Markdown file with some metadata and plain-language instructions, no code required. The harder skills add a scripts folder for code Claude can run or a references folder for documents it reads on demand, but you can go a long way without either. The real skill is in the writing: a sharp description, a short body, and tested instructions. - Q: Won't a big skill slow Claude down or cost a lot? A: A big skill stays cheap because Claude loads skills in layers rather than all at once. At startup it reads only each skill's name and description, about a hundred tokens each. It opens the full body only when your request matches, and opens reference files only when the body points to them. So a skill with a dozen reference documents costs almost nothing for the parts a given task never touches. - Q: How do I actually test a skill? A: Build your test cases before you write the skill, which Anthropic's docs recommend and almost no tutorial follows. Run Claude on a few real tasks without the skill and note where it falls short, then turn those gaps into scenarios with a clear definition of a good answer. The field guide reports that Anthropic's updated skill-creator can now run this for you: an Executor agent runs the skill, a Grader scores the output, and a Comparator does a blind A/B between two versions or between the skill and no skill at all. It also runs inside Cowork, Anthropic's desktop agent for non-developers, so you can describe what good looks like in plain language. - Q: Is it safe to install skills other people wrote? A: Treat it like installing software: only from sources you trust, and read the whole file first when you do not. A SKILL.md is plain text that Claude obeys as instructions, so a malicious one can quietly tell Claude to do something harmful, like leaking an API key. Ordinary code scanners often miss this because the payload is written as prose, not code. The field guide points to scanners built for this surface (it names claudelint and skill-lint), and they belong in your routine the moment you use skills you did not write yourself. - **The Orchestration Tax** by addyosmani: Addy Osmani's essay on why more AI agents don't mean more shipped work, and how to architect your attention like a concurrent system. - Analog: https://analoghq.ai/es/addyosmani/articles/the-orchestration-tax - Source: https://x.com/addyosmani/status/2059844244907696186 - Tags: multi-agent, agentic-workflows, developer-productivity, llm, systems-design, cognitive-load, orchestration, open-source - Best for: Developers building or scaling multi-agent coding workflows; Engineering leads evaluating agentic IDE and orchestration tooling; Anyone feeling busy but noticing shipped output hasn't grown proportionally - Outcomes: A concrete mental model for why more agents can slow throughput instead of raising it; A practical backpressure heuristic: cap agent count to real review capacity; Awareness of cognitive debt as a lagging failure signal in agentic workflows; A design lens for splitting isolated vs. judgment-heavy tasks before launching agents - Q: What is the orchestration tax? A: The orchestration tax is the gap between how fast AI agents produce work and how fast one human can review it. Addy Osmani coined the term at a Google I/O panel to describe the hidden cost of agentic workflows: launching agents is cheap, but closing the loop on their output requires human judgment that does not parallelize. The more agents you run, the deeper the review queue grows, which means throughput can stall even as activity increases. - Q: How does Amdahl's Law apply to AI agent workflows? A: Amdahl's Law states that the speedup gained by parallelizing a task is strictly capped by the fraction of work that must remain serial. Osmani applies this directly to agentic development: agents can run in parallel, but all architectural judgment, conflict resolution, and output verification still route through one human reviewer. That serial fraction sets a hard ceiling on how much value additional agents can add, no matter how many you launch. - Q: What is the practical rule for avoiding the orchestration tax? A: The core heuristic Osmani recommends is backpressure: scale your parallel agent count to match your review capacity, not to whatever the tool UI allows. A concrete signal that you have crossed the threshold is review queue depth, if open agent threads outnumber the diffs you can genuinely evaluate in a session, the system is producing faster than you can absorb. Splitting tasks into isolated (background-safe) work versus complex (judgment-required) work, and batching reviews instead of context-switching, are the two structural fixes the essay proposes. - Q: What is cognitive debt, and why is it a risk in multi-agent systems? A: Cognitive debt is the accumulated loss of mental model that happens when developers accept agent output without genuinely understanding it, because real review has become too exhausting. Osmani and the Diligesker analysis both flag it as a lagging failure signal: the damage does not show on the day the rubber-stamp happens, but when something breaks in production and no one can explain why the system works the way it does. The more agents run without proportional review quality, the faster cognitive debt compounds. - Q: Does the orchestration tax only affect developer attention, or does it also drive up compute costs? A: Both. The human-attention cost is Osmani's primary argument, but the Towards AI breakdown (May 2026) extends the analysis to production infrastructure: every agent boundary creates another opportunity to replay context, supervisor loops add token overhead, tool-call retries multiply model usage, and observability trace storage adds latency and storage cost. A single user request can internally trigger a planning call, multiple specialist calls, memory retrieval, validation, and retries, each one billing tokens. The orchestration tax is therefore both an attention tax and a compute cost tax. - Q: How does this change how teams should design agentic systems? A: Osmani frames it as a systems design problem rather than a personal productivity problem: you should architect your own attention the same way you architect any concurrent system with a bounded resource. Concretely, that means keeping agent parallelism proportional to review throughput, separating isolated tasks (which can safely run in the background) from judgment-heavy tasks (where the human review is the actual work), and treating review queue depth as a leading metric for system health. The Towards AI analysis adds a design-level question teams should ask before adding agents: how much useful progress does this component contribute per model call and token consumed? - **Building recursive agent systems** by leerob: Research synthesis covering two 2025 papers on recursive multi-agent systems: RecursiveMAS and RAH, for developers building agentic pipelines. - Analog: https://analoghq.ai/es/leerob/articles/building-recursive-agent-systems - Source: https://x.com/leerob/status/2065469795529588940 - Tags: multi-agent, recursion, agent-systems, llm, scaling, research, open-source, code-generation - Best for: Developers designing or evaluating multi-agent orchestration architectures; ML researchers exploring recursion as a scaling axis beyond model size; Engineers hitting token-cost or latency walls with flat multi-agent pipelines - Outcomes: Understand two distinct recursive agent architectures and when each applies; Quantified benchmarks to compare against your own pipeline (8.3% accuracy; 2.4x speedup; 75.6% token reduction for RecursiveMAS; 71.75% to 81.36% on Oolong-Synthetic for RAH); A concrete decision rule for when to use RAH-style vs RecursiveMAS-style recursion; Vocabulary for discussing latent-state transfer vs harness recursion with your team - Q: What is RecursiveMAS and what problem does it solve? A: RecursiveMAS (arXiv:2604.25917) is a multi-agent framework that replaces text-based communication between agents with latent-state recursion, treating the entire system as a unified recursive computation graph. Standard multi-agent systems pass token strings between agents, which is slow and token-expensive. RecursiveMAS instead transfers hidden states directly via a two-layer residual module called RecursiveLink, enabling agents to collaborate in continuous latent space across multiple recursion rounds. The result across 9 benchmarks is an average 8.3% accuracy gain, up to 2.4x speedup, and up to 75.6% fewer tokens versus text-based baselines. - Q: What is a Recursive Agent Harness (RAH) and how does it differ from RecursiveMAS? A: A Recursive Agent Harness (RAH), introduced in arXiv:2606.13643 by PwC researchers, makes the recursive unit a full agent harness complete with filesystem tools, code execution, and planning, rather than a bare model call or latent state. A parent agent writes an executable script that spawns subagent harnesses in parallel. Each subagent carries the same spawning capability as its parent, so decomposition is genuinely recursive and bounded only by a configurable depth limit. Where RecursiveMAS requires fine-tuning to share gradients across recursion rounds, RAH is code-first and closer to patterns already expressible in existing orchestration frameworks. - Q: What benchmarks and results do these papers report? A: RecursiveMAS evaluates across 9 benchmarks spanning mathematics, science, medicine, search, and code generation, reporting a consistent average accuracy improvement of 8.3%, end-to-end inference speedup of 1.2x to 2.4x, and token usage reduction of 34.6% to 75.6% versus text-based multi-agent and recursive computation baselines. The RAH paper uses the Oolong-Synthetic benchmark (199 samples across 13 context-length buckets up to 4M tokens) to evaluate long-context reasoning. With GPT-5 as the backbone, RAH improves the Codex coding-agent baseline from 71.75% to 81.36%. With Claude Sonnet 4.5 as the backbone, the same RAH design reaches 89.77%. - Q: What is RecursiveLink and why is it central to RecursiveMAS? A: RecursiveLink is a lightweight two-layer residual module that connects heterogeneous agents in RecursiveMAS by transmitting latent states across two transition types. The inner link maps an agent's last-layer hidden state back into its input embedding space so the agent continues generating in continuous latent space without projecting to tokens. The outer link performs cross-agent latent state transfer, passing the hidden stream from one agent to the next. Because no tokenization happens between agents, the system avoids the computational overhead of sampling and re-encoding, which is the primary source of the reported speedup and token savings. - Q: Can I use these recursive patterns with existing orchestration frameworks like LangGraph or AutoGen? A: RAH patterns are conceptually close to what frameworks like LangGraph and AutoGen already support: a parent agent that spawns child agents with shared tool access. The key RAH addition is using code-execution spawning (writing a runnable script as the branching mechanism) rather than relying solely on JSON tool calls, which the authors argue is better suited for fine-grained parallel workloads with thousands of independent entries. RecursiveMAS, by contrast, requires fine-tuning access to participate in its inner-outer loop gradient-based credit assignment, so it cannot be replicated purely through prompt engineering or standard orchestration wiring. - Q: What are the main limitations or risks of recursive agent architectures? A: RecursiveMAS requires training access to the underlying models to co-optimize the system via shared gradients across recursion rounds, making it inaccessible for teams working exclusively with closed APIs. RAH's recursive decomposition is bounded by a configurable depth limit, but the authors note that tasks requiring per-entry LLM reasoning across thousands of independent entries are the target use case, and simpler tasks may not benefit from the added complexity. Neither paper ships as a production library at the time of writing, so builders would need to implement the patterns themselves. The RAH paper also notes that coding agents currently reduce per-entry reasoning to regex heuristics - **How to Actually Use Claude. 18 steps that unlock 100% of its potential** by anatolikopadze: An 18-step practical guide to unlocking Claude's full capability through Projects, Custom Instructions, and a personal knowledge base. - Analog: https://analoghq.ai/es/anatolikopadze/articles/how-to-actually-use-claude - Source: https://x.com/AnatoliKopadze/status/2054568935274549597 - Tags: claude, prompting, custom-instructions, projects, ai-setup, productivity, beginner, open-source - Best for: Daily Claude users who want persistent, personalized context without re-explaining themselves every session; Non-technical users setting up Claude's web interface for the first time with a structured workflow; Builders who want to encode tone, format, and behavioral constraints into a reusable Project setup; Anyone doing document-heavy or research-heavy workflows who needs a repeatable delegation pattern - Outcomes: An 18-step end-to-end Claude Project configuration that loads personal context once and persists it across all sessions; A fill-in-the-blank identity template covering role, goals, knowledge level, and preferred communication style; A set of negative-space instructions that eliminate unwanted default behaviors like disclaimers and filler phrases; Structured prompting patterns for task delegation, document workflows, and multi-step research the guide argues most users never attempt - Caveats: The core claim that average users tap only 5-10% of capability is the author's editorial estimate, not a measured or Anthropic-cited benchmark; Token and file-size limits for the Project knowledge base are not published in the guide, so builders loading large documents should verify limits at claude.ai; The guide targets the Claude web interface and may not translate directly to API or third-party integrations; Published May 2026, so platform details may shift as Anthropic updates Projects features - Q: What does this article actually teach? A: This is an 18-step end-to-end Claude setup guide covering Projects, Custom Instructions, a personal knowledge base, and a full suite of advanced prompting patterns. The first three steps build a persistent configuration so Claude retains your identity, role, goals, and communication preferences across every session. Steps 4 through 18 extend that foundation into task delegation, document workflows, and use cases the article claims most users have never attempted. The core thesis is that roughly 5-10% capability usage is the norm among daily users, and that a one-hour setup permanently closes the gap. - Q: How do I write Custom Instructions step by step? A: First, create a Claude Project by clicking Projects in the sidebar at claude.ai and naming it something like 'Work' or 'Personal.' Second, paste the article's fill-in-the-blank identity template into the Project's knowledge base, filling in your name, role, responsibilities, goals, knowledge level, preferred response style, and explicit 'things I do NOT want' constraints. Third, prompt Claude directly: 'Based on everything I've told you about myself, write me a set of custom instructions for this Claude Project.' Claude will generate a structured instruction set from your template. Save the output to the Project so it loads automatically at the start of every future session. - Q: Is this guide free to follow, and do I need a paid Claude account? A: The article itself is freely available across all three published sources (agent-cookbook.com, dev.to, and a Substack newsletter). The guide's features, specifically Projects with persistent knowledge bases, are tied to Claude's interface at claude.ai. The sources do not specify which Claude subscription tier unlocks Projects, so readers should verify current plan requirements directly at claude.ai before committing to the setup workflow. - Q: What is the single most underrated technique in the guide? A: Per the article, negative-space instructions are the most overlooked lever in Claude prompting. Most users tell Claude what they want; the guide argues that explicitly listing what you do NOT want, such as 'no disclaimers,' 'no corporate language,' 'never start with Great question,' shapes Claude's default behavior at a level positive instructions alone rarely achieve. These constraints are added directly to your Custom Instructions and apply across every conversation in the Project automatically. - Q: How does using a Claude Project compare to just using a well-crafted system prompt? A: A Claude Project as described in the article provides a persistent, session-spanning workspace with a knowledge base that loads automatically, whereas a one-off system prompt must be re-supplied at the start of each new conversation or API call. The article frames Projects as the interface-level solution for users who want context retention without managing it manually each time. Developers working via the API will need to replicate the same effect through system prompts and context injection, since the Project feature is specific to Claude's web interface. - Q: What are the limitations of this approach? A: The article does not cite Anthropic documentation for the capability-usage estimate it references, so the '5-10%' figure should be treated as the author's editorial framing rather than a measured benchmark. The guide also does not publish current token or file limits for Claude's Project knowledge base, so builders planning to load large documents should verify limits directly at claude.ai, as these constraints can change with platform updates. Additionally, the guide is written for the claude.ai web interface; API users will need to adapt each step to system-prompt and context-management equivalents. - **You're doing RAG wrong** by akshay-pachaar: A technical argument for replacing text chunks with structured QA packets in RAG pipelines, for ML engineers and data architects building production retrieval systems. - Analog: https://analoghq.ai/es/akshay-pachaar/articles/youre-doing-rag-wrong - Source: https://x.com/akshay_pachaar/status/2052743644411765230 - Tags: rag, retrieval, llm, vector-search, embeddings, open-source, data-architecture, production-ai - Best for: ML engineers and data architects who own a RAG ingestion pipeline and want to fix retrieval at the source; Teams struggling with stale, duplicate, or access-controlled content bleeding into LLM answers; Builders who want measurable retrieval gains without swapping their embedding model or reranker - Outcomes: A QA-packet ingestion pattern that replaces prose chunks with one-question, one-answer, one-governance-object units; Reported 40x corpus size reduction, 3x fewer tokens per query, and 2.3x improvement in vector search relevance; Tighter cosine distance between query and stored unit because user queries and QA packets share the same structural form; Typed governance fields such as version state, clearance level, and source kept on the same object as the content they govern; A custom document-transformation stage blueprint: extract claims, generate QA pairs, attach metadata, then embed - Caveats: Reported gains come from a single dev.to article (2024) and one agntai.net practitioner thread, not peer-reviewed benchmarks; LangChain, LlamaIndex, and Haystack do not natively support QA-packet transformation, so a custom ingestion stage is required; The access-control and version-state problem is structural; bolting filters onto the orchestrator instead of the content object is flagged as a root cause; Embedding model mismatch is called out as a parallel failure mode, meaning QA packets alone may not be sufficient without model alignment - Q: What is the central argument of 'You're doing RAG wrong'? A: The article argues that the chunk is the wrong unit of knowledge for RAG, and that this ingestion-layer mistake causes most of the retrieval failures developers try to fix with better rerankers or embedding models. Per the dev.to source by Manideep Patibandla, replacing prose chunks with structured question-answer packets fixes the problem upstream and produces reported gains of 40x corpus reduction, 3x fewer tokens per query, and 2.3x better vector search relevance. The argument is that no retrieval algorithm can fully compensate for structurally broken input. - Q: What is a QA packet and how does it differ from a standard chunk? A: A QA packet is a structured unit holding one question, its validated answer, and typed governance metadata such as version state, clearance level, and source, all on the same object. A standard chunk is a fixed-size prose window cut at token boundaries with no idea boundaries, no version state, and no embedded access-control metadata. Because user queries are already questions, embedding a QA packet produces a direct structural match with incoming query embeddings, tightening cosine distance compared to a prose window that only incidentally contains the answer. - Q: Is there a tool that implements QA packets, and is it free to use? A: Blockify, a preprocessing layer from Iternal Technologies, implements the QA-packet pattern using a structure it calls an IdeaBlock. Each IdeaBlock holds a question, its validated answer, and typed governance fields. The sources do not provide pricing or licensing details for Blockify, but the QA-packet pattern itself is an architectural approach any team can implement as a custom document-transformation stage before writing to a vector store, without requiring a specific commercial product. - Q: What other root causes do the articles identify beyond chunk boundaries? A: The agntai.net practitioner article (updated May 2026) identifies embedding model mismatch as a major, independent failure mode: teams use generic sentence-transformers models without evaluating domain fit, and one reported case showed a 35% relevance lift from switching to OpenAI's text-embedding-ada-002 for domain-specific text. The same source flags database over-engineering, teams with 10,000 documents using distributed vector systems that belong at a million-document scale, and the inverse problem of under-powered stores for large corpora. The Towards AI article also highlights context blindness, where retrieved chunks lack enough surrounding information to be interpreted correctly, and - Q: How does fixing the ingestion layer compare to tuning the retrieval layer? A: Switching the knowledge unit outperforms retrieval tuning on the metrics reported in the dev.to article: QA packets yield 40x corpus reduction and 2.3x relevance improvement without touching the reranker, embedding model, or retrieval algorithm. Retrieval-layer fixes, such as reranking or hybrid search, operate on whatever the vector store contains and cannot recover information destroyed by bad chunk boundaries or deduplicate mixed-version paragraphs that were never tagged at ingestion. The articles position ingestion-layer fixes as higher leverage because they address the structural cause rather than compensating for it. - Q: What are the main limitations or risks of this approach? A: The sources report benchmark numbers (40x, 3x, 2.3x, 35%) without naming the specific datasets, model versions, or experimental conditions used, so these figures should be treated as directional rather than universally reproducible. Generating QA packets at scale requires an additional extraction step, either manual curation or an LLM-assisted pipeline, which adds latency and cost to ingestion. The sources also note that LangChain, LlamaIndex, and Haystack do not implement QA-packet transformation by default, so teams adopting this approach need to build or integrate a custom preprocessing stage before the vector store write. - **Frontend Guidelines** by bendc: Un conjunto conciso y con criterio propio de buenas prácticas de HTML, CSS y JavaScript sobre semántica, accesibilidad, rendimiento y patrones mantenibles, cada una ilustrada con ejemplos de código malo frente a bueno. - Analog: https://analoghq.ai/es/bendc/articles/frontend-guidelines - Source: https://github.com/bendc/frontend-guidelines - Repo: https://github.com/bendc/frontend-guidelines - Tags: html, css, javascript, best-practices, open-source, style-guide, accessibility, frontend - Pricing: free - Features: Reglas concisas de buenas prácticas de HTML, CSS y JavaScript; Cada regla ilustrada con un ejemplo de código malo frente a bueno; Guía de HTML sobre semántica, accesibilidad y rendimiento; Guía de CSS sobre flujo, especificidad, layout y animación; Guía de JavaScript sobre pureza, métodos nativos y legibilidad; Adoptable como base para un equipo o referencia de incorporación - Best for: Establecer una base de convenciones frontend para un equipo; Incorporar ingenieros a las buenas prácticas de HTML/CSS/JS; Una referencia rápida durante la revisión de código - Outcomes: Marcado consistente, semántico y accesible; CSS con menor especificidad y más mantenible; JavaScript más legible y con menos efectos secundarios - Caveats: Conciso y con criterio propio, no es una especificación completa; Los ejemplos son HTML/CSS/JS estándar, no específicos de ningún framework - Cost note: Gratuito para leer; documento abierto. - Q: ¿Qué cubre Frontend Guidelines? A: Buenas prácticas en tres áreas: HTML (semántica, accesibilidad, rendimiento), CSS (flujo, especificidad, layout moderno, animación) y JavaScript (pureza, métodos nativos, legibilidad). - Q: ¿A quién va dirigido? A: A equipos que quieran una base de convenciones frontend lista para usar, y a ingenieros que se incorporan a una base de código y necesitan una referencia rápida y con criterio propio. - Q: ¿Cuál es su principio fundamental? A: Favorecer la legibilidad, la corrección y la expresividad por encima del micro-rendimiento; el documento argumenta que JavaScript rara vez es tu cuello de botella, por lo que hay que optimizar las imágenes, la red y los reflujos del DOM.