`, or a canvas-drawn element. **Regulated Industry Data Entry** Healthcare claims processing, insurance underwriting, financial compliance reporting—all involve structured data entry across complex forms with strict accuracy requirements. Record a demonstrator performing the task correctly, scrub sensitive data with `openadapt-privacy`, then deploy agents that replicate that exact behavior with audit trails. **Accessibility Testing and Remediation** By leveraging the accessibility tree capture alongside visual information, OpenAdapt can verify that applications are actually usable with assistive technologies, not just technically compliant. The `openadapt-grounding` package's UI element localization helps identify where focus management and screen reader announcements break down. ## Step-by-Step Installation & Setup Guide Getting started with OpenAdapt takes minutes, not hours. The modular installation lets you start minimal and expand as needed. ### Prerequisites You'll need **Python 3.10 or newer**. Verify your version: ```bash python --version # Must show 3.10.x or higher ``` ### Platform-Specific Permissions **macOS users**: Grant three critical permissions to your terminal application: - **Accessibility**: Allows reading UI element structure - **Screen Recording**: Enables screenshot capture for visual understanding - **Input Monitoring**: Permits recording of keyboard and mouse actions Navigate to System Preferences → Security & Privacy → Privacy → [Permission Type], then add your terminal emulator. **Windows users**: Run your terminal as Administrator when capturing input events. This ensures reliable mouse and keyboard recording. ### Installing OpenAdapt Choose your installation path based on your needs: ```bash # Minimal installation - CLI only, no capture or ML pip install openadapt # Include GUI capture and recording capabilities pip install openadapt[capture] # Add machine learning training and inference pip install openadapt[ml] # Include benchmark evaluation tools pip install openadapt[evals] # Add privacy scrubbing for PII/PHI pip install openadapt[privacy] # Install everything for full functionality pip install openadapt[all] ``` For development work on sub-packages, clone and install in editable mode: ```bash git clone https://github.com/OpenAdaptAI/openadapt-ml cd openadapt-ml pip install -e ".[dev]" ``` ### Verifying Installation Run the built-in system check: ```bash openadapt doctor ``` This validates your Python version, required permissions, and available sub-packages. Address any warnings before proceeding. Check installed versions across the ecosystem: ```bash openadapt version ``` ## REAL Code Examples: From Recording to Autonomous Execution Let's walk through OpenAdapt's actual CLI usage, drawn directly from the repository documentation. These aren't toy examples—they're the commands you'll use in production. ### Example 1: Recording Your First Demonstration The foundation of everything in OpenAdapt is the capture. Here's how you record a task: ```bash # Start recording with a descriptive name openadapt capture start --name invoice-processing # Perform your normal workflow in any GUI application: # - Open your accounting software # - Navigate to unpaid invoices # - Select the first invoice # - Click "Process Payment" # - Enter payment details # - Save and confirm # Press Ctrl+C in the terminal to stop recording ``` **What's happening under the hood:** `openadapt-capture` subscribes to system-level input events and takes periodic screenshots. Each action is timestamped and correlated with the visual state. The accessibility tree (on macOS via `atomacos`, Windows via UI Automation) provides structured element information alongside raw pixels. This multimodal recording becomes your demonstration trajectory. ### Example 2: Training a Vision-Language Model Once you have demonstrations, train a model to replicate them: ```bash # Train on your capture using Qwen3-VL 2B parameter model openadapt train start --capture invoice-processing --model qwen3vl-2b # Monitor training progress in another terminal openadapt train status # Stop training if needed (graceful checkpoint saving) openadapt train stop ``` **The technical depth:** OpenAdapt loads your demonstration trajectories and fine-tunes the vision-language model using a custom loss function that emphasizes **action prediction conditioned on visual state and demonstration context**. The `--model` flag accepts various architectures—Qwen3-VL for efficiency, larger models for complex reasoning. Training outputs checkpoints to `training_output/model.pt` by default. ### Example 3: Evaluating Trained Agents Before deploying, validate your model's performance: ```bash # Evaluate your trained checkpoint against a benchmark openadapt eval run --checkpoint training_output/model.pt --benchmark waa # Or evaluate an API-based agent without local training openadapt eval run --agent api-claude # Quick smoke test with mock tasks openadapt eval mock --tasks 10 ``` **Why this matters:** The `waa` benchmark (likely "Web/App Automation") provides standardized tasks with known success criteria. Running evaluation before production deployment catches failure modes early. The mock evaluation (`--tasks 10`) gives instant feedback on your setup without requiring full model weights. ### Example 4: Viewing and Managing Captures Inspect your recordings for quality assurance: ```bash # List all recorded demonstrations openadapt capture list # Visualize a specific capture in your browser openadapt capture view invoice-processing ``` The `openadapt-viewer` package renders an HTML visualization showing screenshots, action overlays, and accessibility tree snapshots synchronized in time. This is invaluable for debugging why a particular demonstration led to unexpected model behavior. ### Example 5: Starting the Dashboard Server For team collaboration and monitoring: ```bash # Launch the web dashboard on port 8080 openadapt serve --port 8080 ``` Navigate to `http://localhost:8080` to access the dashboard. This centralizes capture management, training job monitoring, and evaluation results for team visibility. ## Advanced Usage & Best Practices **Build a Demonstration Library, Not Single Tasks** The power of OpenAdapt's retrieval path comes from **demonstration diversity**. Record the same task performed on different screen resolutions, with varying window arrangements, and across UI themes. This builds robustness that single-demonstration approaches lack. **Leverage the Abstraction Ladder** Start with literal replay for critical tasks—exact mouse coordinates, precise timing. As you gain confidence, progress through template-based matching ("click the button labeled 'Submit'") to goal-level automation ("complete the payment flow"). The `openadapt-ml` training path supports this progression with different fine-tuning objectives. **Implement Multi-Model Consensus for Critical Operations** For high-stakes automation, deploy `openadapt-consilium` to run multiple models in parallel. If Claude, GPT-4o, and Qwen3-VL all agree on an action, execute automatically. On disagreement, escalate to human review via `openadapt-crier`. This "swarm intelligence" pattern dramatically reduces error rates. **Privacy Scrub Before Any Sharing** Even within your organization, run `openadapt-privacy` on all captures before adding them to shared demonstration libraries. The scrubbing runs locally—no data leaves your machine—removing names, emails, account numbers, and other sensitive patterns using both regex and ML-based detection. **Version Your Demonstrations Like Code** Use `openadapt-herald` to auto-generate social media and changelog content from your git history, but more importantly, tag demonstration datasets with semantic versions. "Invoice processing v2.1.0" is infinitely more maintainable than "that recording from March." ## OpenAdapt vs. The Competition | Capability | OpenAdapt | Traditional RPA (UiPath, AA) | Browser Automation (Playwright, Selenium) | Commercial AI Agents (Adept, Rabbit) | |---|---|---|---|---| | **Visual Understanding** | ✅ Native (LMM-powered) | ❌ Pixel-based, brittle | ❌ DOM-dependent only | ✅ Yes, but proprietary | | **Cross-Application** | ✅ Desktop + Web seamlessly | ⚠️ Requires separate automations | ❌ Browser only | ⚠️ Limited by platform | | **Open Source** | ✅ MIT License | ❌ Proprietary | ✅ Open source | ❌ Closed source | | **Self-Hostable** | ✅ Fully | ⚠️ On-prem options costly | ✅ Yes | ❌ Cloud-dependent | | **Demo-Conditioned Runtime** | ✅ Unique differentiator | ❌ Rule-based only | ❌ No demonstration concept | ⚠️ Training only | | **Privacy Scrubbing** | ✅ Built-in | ⚠️ Add-on products | ❌ Not applicable | ❌ Opaque | | **Cost at Scale** | ✅ Compute only | ❌ Per-bot licensing | ✅ Free (self-run) | ❌ Subscription/API fees | | **Custom Model Training** | ✅ Fine-tune VLMs | ❌ Not applicable | ❌ Not applicable | ❌ Black box | **The verdict:** Traditional RPA tools demand you describe every interaction explicitly. Browser automations break when developers refactor CSS. Commercial AI agents offer convenience at the cost of control and transparency. OpenAdapt occupies the unique position of **cutting-edge AI capability with full open-source freedom**. ## Frequently Asked Questions **Is OpenAdapt production-ready today?** The v1.0+ modular architecture is actively developed with validated results on controlled benchmarks. The retrieval-conditioned prompting (Phase 2) is validated; demo-conditioned fine-tuning (Phase 3) is in progress. Start with supervised execution and progress to autonomy as your evaluation metrics support it. **What hardware do I need for local model training?** The Qwen3-VL 2B model trains efficiently on consumer GPUs with 8GB+ VRAM. For larger models or faster training, cloud GPU instances work seamlessly. Inference with API-based models (Claude, GPT-4o) requires no local GPU. **Can OpenAdapt handle applications with heavy anti-automation?** OpenAdapt operates at the OS input level and uses visual understanding, making it inherently harder to detect than DOM-manipulating tools. However, always respect Terms of Service and legal requirements for target applications. **How does demonstration privacy scrubbing work?** `openadapt-privacy` combines pattern matching for known PII formats (SSNs, credit cards, emails) with transformer-based named entity recognition. All processing happens locally; no data is transmitted externally. **What happens when the UI changes significantly?** This is where demo-conditioned inference shines. Unlike brittle selectors, OpenAdapt's visual understanding tolerates layout changes, theme updates, and responsive reflows. For major redesigns, record new demonstrations—the retrieval system will match to the most relevant examples automatically. **Can I contribute to the project?** Absolutely. Join the [Discord community](https://discord.gg/yF527cQbDG), pick issues from any sub-package repository, and submit PRs. The modular architecture means you can contribute to `openadapt-grounding` without understanding `openadapt-ml` internals. **Is there a graphical interface, or only CLI?** Both. `openadapt-desktop` provides a full GUI application, while `openadapt-tray` offers a lightweight system tray app for quick capture start/stop. The CLI remains the power-user interface for scripting and automation. ## Conclusion: The Future of Automation Is Demonstration, Not Scripting OpenAdapt represents a fundamental paradigm shift in how we automate computer interactions. Instead of painstakingly describing every click, scroll, and keystroke through brittle abstractions, we **demonstrate** and let intelligent models **learn** the underlying intent. The 100% first-action accuracy achieved through demo-conditioned prompting isn't just a number—it's proof that "show, don't tell" works for human-computer interaction automation. The modular architecture gives you control. The open-source license gives you freedom. The multimodal foundation gives you robustness that rule-based systems simply cannot match. Whether you're automating legacy healthcare systems, testing dynamic web applications, or building the next generation of AI agents, OpenAdapt provides the bridge between cutting-edge vision-language models and the interfaces humans actually use every day. **Stop writing scripts that break. Start demonstrating tasks that scale.** 👉 **Get started now:** Clone the repository at [github.com/OpenAdaptAI/OpenAdapt](https://github.com/OpenAdaptAI/OpenAdapt), install with `pip install openadapt[all]`, and record your first demonstration in under five minutes. Join the [Discord community](https://discord.gg/yF527cQbDG) to share what you build and help shape the future of generative process automation. The robots aren't coming for your job—they're coming to do the boring parts of it. With OpenAdapt, you're the one teaching them how.]]>Mohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/openadapt-automate-any-gui-with-vision-ai-no-codeTue, 27 Oct 2026 10:32:00 +0100https://converter.brightcoding.dev/blog/stop-building-ai-agents-from-scratch-use-skillnet-instead`. No cloning, no dependency resolution headaches, no manual file organization. Skills arrive as structured packages ready for immediate use. **✨ Auto-Create from Any Source** This is where SkillNet gets genuinely magical. The platform can transform **GitHub repositories**, **PDF/PPT/Word documents**, **conversation logs**, **execution traces**, or even **plain text prompts** into structured skill packages using LLM-powered pipelines. Have a 50-page technical guide? Drop it in, get a skill. Have a successful agent conversation? The trajectory becomes reusable capability. **📊 5-Dimensional Quality Evaluation** Every skill can be scored across **Safety** (harmful output prevention), **Completeness** (coverage of edge cases), **Executability** (runtime success rate), **Maintainability** (code quality and documentation), and **Cost-Awareness** (token efficiency and API spend). This transforms skill selection from guesswork into engineering discipline. **🕸️ Auto-Generated Skill Graph** The relationship analysis engine automatically discovers how skills connect. You'll see that `PDF_Parser` `compose_with` `Text_Summarizer`, or that `Web_Scraper` `depend_on` `Rate_Limiter`. This graph enables intelligent skill composition and prevents dependency conflicts. ## Real-World Use Cases Where SkillNet Dominates ### 1. Accelerating Scientific Research Workflows Consider a bioinformatics team analyzing single-cell RNA sequencing data to identify cancer therapeutic targets. Traditionally, they'd build custom pipelines from scratch—data ingestion, quality control, differential expression analysis, pathway enrichment, target validation. With SkillNet, their agent **searches** for `cellxgene-census` and `kegg-database` skills, **evaluates** them for quality, then **composes** them into an automated workflow. The platform's scientific discovery demo shows this exact pipeline: from raw data to validated target report, with skills discovered and quality-gated at each step. ### 2. Enterprise Document Processing Pipelines Organizations drowning in unstructured documents—contracts, reports, manuals—can leverage SkillNet's auto-creation capability. Upload a PDF processing guide, and the platform generates a structured skill. Combine it with extracted table parsing and summarization skills from the community. The 5D evaluation ensures production readiness before deployment. ### 3. Multi-Agent System Development When building systems where multiple agents collaborate, skill compatibility becomes critical. The Skill Graph's `depend_on` and `compose_with` relationships prevent runtime failures from mismatched interfaces. Teams can publish agent-specific skills to private repositories, evaluate them internally, and share selectively. ### 4. IDE-Integrated Agent Augmentation With the MCP server integration, developers using Claude Desktop, Cursor, Antigravity, or Windsurf can search and install skills without leaving their coding environment. Need a Docker management skill? Ask your IDE's agent to find and install it. The friction between "I need this capability" and "I have this capability" approaches zero. ## Step-by-Step Installation & Setup Guide Getting started with SkillNet takes under two minutes. The platform supports Python 3.9+ and offers multiple installation paths. ### Standard Installation ```bash # Using pip pip install skillnet-ai # Or using uv for faster, modern Python package management uv venv source .venv/bin/activate # On Windows: .venv\Scripts\activate uv pip install skillnet-ai ``` ### Environment Configuration For basic search and download operations, **no API key is required**. For creating, evaluating, and analyzing skills, configure your LLM provider: **Linux / macOS:** ```bash export API_KEY="sk-your-openai-key-here" export BASE_URL="https://api.openai.com/v1" # Optional: for custom endpoints export GITHUB_TOKEN="ghp-your-token-here" # Optional: for private repositories export SKILLNET_MODEL="gpt-4o" # Optional: default model override export GITHUB_MIRROR="https://ghfast.top/" # Optional: for restricted networks ``` **Windows PowerShell:** ```powershell $env:API_KEY = "sk-your-openai-key-here" $env:BASE_URL = "https://api.openai.com/v1" $env:GITHUB_TOKEN = "ghp-your-token-here" ``` ### Verification ```python from skillnet_ai import SkillNetClient # Initialize client—no API key needed for search/download client = SkillNetClient() # Quick verification: search for PDF-related skills results = client.search(q="pdf", limit=3) print(f"Found {len(results)} skills") if results: print(f"Top skill: {results[0].skill_name} with {results[0].stars} stars") ``` ### OpenClaw Integration (Optional) For autonomous agent operation, install the SkillNet skill in OpenClaw: ```bash npm i -g clawhub clawhub install skillnet --workdir ~/.openclaw/workspace openclaw gateway restart ``` Then configure in `openclaw.json`: ```json { "skills": { "entries": { "skillnet": { "enabled": true, "apiKey": "sk-your-key-here", "env": { "BASE_URL": "https://api.openai.com/v1", "GITHUB_TOKEN": "ghp-your-token-here" } } } } } ``` ## REAL Code Examples from SkillNet Let's walk through production-ready code patterns using the actual SDK, extracted directly from the repository documentation. ### Example 1: Search and Install Workflow ```python from skillnet_ai import SkillNetClient # Initialize with zero configuration for public operations client = SkillNetClient() # No API key needed for search & download # --- KEYWORD SEARCH --- # Fast fuzzy matching for exact terminology results = client.search(q="pdf", limit=5) print(f"{results[0].skill_name} ⭐{results[0].stars}") # Output: pdf-extractor-v1 ⭐128 # --- SEMANTIC SEARCH --- # AI-powered intent understanding for natural language queries results = client.search( q="analyze financial PDF reports", # Describe your need, not just keywords mode="vector", # Enable semantic mode threshold=0.85 # Minimum similarity score (0.0-1.0) ) # --- INSTALL SKILL --- # Download to local directory for immediate use local_path = client.download( url=results[0].skill_url, # GitHub URL from search results target_dir="./my_skills" # Organized local skill library ) print(f"Skill installed to: {local_path}") ``` **What's happening here?** The `SkillNetClient` operates in two modes. Without an API key, you get full search and download capabilities—perfect for exploration and building your skill library. The `mode="vector"` parameter switches from keyword matching to embedding-based semantic search, which understands that "analyze financial PDF reports" relates to skills about extraction, table parsing, and report generation even if they don't contain those exact words. ### Example 2: Auto-Create Skills from Diverse Sources ```python from skillnet_ai import SkillNetClient client = SkillNetClient(api_key="sk-...") # Required for creation # --- FROM EXECUTION TRAJECTORIES --- # Turn successful agent conversations into reusable skills client.create( trajectory_content="User: rename .jpg to .png\nAgent: Done.", output_dir="./skills" ) # The LLM extracts the pattern, generalizes it, and packages it # --- FROM GITHUB REPOSITORIES --- # Transform existing codebases into structured skills client.create( github_url="https://github.com/zjunlp/DeepKE", # Knowledge extraction toolkit output_dir="./skills" ) # Auto-generates: description, parameters, examples, dependencies # --- FROM OFFICE DOCUMENTS --- # Convert institutional knowledge into agent capabilities client.create( office_file="./guide.pdf", # PDF, PPT, or Word documents output_dir="./skills" ) # Extracts procedures, constraints, and decision logic # --- FROM NATURAL LANGUAGE --- # The fastest path: describe what you want client.create( prompt="A skill for web scraping article titles with rate limiting", output_dir="./skills" ) # LLM generates complete implementation with error handling ``` **Why this matters:** The `create` method is SkillNet's secret weapon for **knowledge capitalization**. Organizations have decades of expertise trapped in documents, conversation logs, and legacy code. This single API call transforms that dormant knowledge into structured, evaluable, shareable skills. The trajectory example is particularly powerful—every successful agent interaction becomes a training example for future capabilities. ### Example 3: Quality Evaluation and Relationship Analysis ```python from skillnet_ai import SkillNetClient client = SkillNetClient(api_key="sk-...") # --- 5-DIMENSION QUALITY EVALUATION --- # Score any skill before trusting it in production result = client.evaluate( target="https://github.com/anthropics/skills/tree/main/skills/algorithmic-art" # Also accepts: local paths like "./my_skills/web_search" ) # Returns structured quality report: # { # "safety": {"level": "Good", "reason": "No harmful outputs detected..."}, # "completeness": {"level": "Excellent", "reason": "Handles 12 edge cases..."}, # "executability": {"level": "Good", "reason": "Success rate 94% across..."}, # "maintainability": {"level": "Fair", "reason": "Missing type hints..."}, # "cost_awareness": {"level": "Good", "reason": "Average 2,400 tokens..."} # } # --- SKILL GRAPH ANALYSIS --- # Discover how your skills relate to each other relationships = client.analyze(skills_dir="./my_skills") for rel in relationships: print(f"{rel['source']} --[{rel['type']}]--> {rel['target']}") # Example output: # PDF_Parser --[compose_with]--> Text_Summarizer # Web_Scraper --[depend_on]--> Rate_Limiter # Data_Cleaner --[similar_to]--> Data_Validator # Image_Classifier --[belong_to]--> Computer_Vision ``` **The evaluation system** replaces "vibe checking" skills with rigorous, multi-dimensional assessment. Before deploying a community skill in production, you can verify it won't generate harmful outputs, handles edge cases, runs reliably, can be maintained by your team, and won't explode your API budget. The relationship analysis then enables **intelligent composition**—knowing that `PDF_Parser` works well with `Text_Summarizer` because others have composed them successfully. ### Example 4: REST API for Lightweight Integration ```bash # No authentication required—completely free public API # Keyword search with sorting and filtering curl "http://api-skillnet.openkg.cn/v1/search?q=pdf&sort_by=stars&limit=5" # Semantic search for intent-based discovery curl "http://api-skillnet.openkg.cn/v1/search?q=reading%20charts&mode=vector&threshold=0.8" # Filtered by category with minimum quality bar curl "http://api-skillnet.openkg.cn/v1/search?q=visualization&category=Development&min_stars=10" ``` **Response format:** ```json { "data": [ { "skill_name": "pdf-extractor-v1", "skill_description": "Extracts text and tables from PDF documents.", "author": "openkg-team", "stars": 128, "skill_url": "https://...", "category": "Productivity" } ], "meta": { "query": "pdf", "mode": "keyword", "total": 1, "limit": 10 }, "success": true } ``` ## Advanced Usage & Best Practices **Mirror Strategy for Restricted Networks:** If you're behind corporate firewalls or in regions with GitHub access issues, always configure `GITHUB_MIRROR=https://ghfast.top/` or pass `--mirror` to download commands. This single setting prevents 90% of installation failures in enterprise environments. **Lazy Loading in Agent Frameworks:** When integrating with OpenClaw or JiuwenClaw, let the agent search for skills at runtime rather than pre-installing everything. This keeps agent memory usage low and ensures skills are fresh. The periodic `analyze` command then garbage-collects unused skills and identifies composition opportunities. **Version Pinning for Reproducibility:** While SkillNet doesn't enforce semantic versioning yet, pin skill installations to specific commit hashes for production systems: `skillnet download @`. This prevents breaking changes from upstream modifications. **Batch Evaluation Before Deployment:** Run `skillnet evaluate` on all skills in your local directory before major releases. The CLI supports batch operations: `for skill in ./skills/*/; do skillnet evaluate "$skill"; done`. **Custom LLM Endpoints:** For cost control or data privacy, configure `BASE_URL` to route creation and evaluation through local models (vLLM, Ollama) or enterprise providers. The SDK is endpoint-agnostic. ## Comparison with Alternatives | Capability | SkillNet | LangChain Hub | Hugging Face Tools | Custom Registries | |:---|:---|:---|:---|:---| | **Search** | Keyword + Semantic vector | Keyword only | Model-centric | Varies | | **Install** | One-line `skillnet download` | Manual copy/paste | `pip install` | Varies | | **Auto-Create** | Repos, docs, logs, prompts | ❌ No | ❌ No | ❌ No | | **Quality Scoring** | 5D evaluation (safety, completeness, executability, maintainability, cost) | ❌ No | Limited benchmarks | ❌ No | | **Relationship Graph** | Auto `similar_to`, `belong_to`, `compose_with`, `depend_on` | ❌ No | ❌ No | ❌ No | | **API Authentication** | None for search/download | Required | Required | Varies | | **MCP Integration** | Native server for Claude/Cursor/Windsurf | ❌ No | ❌ No | ❌ No | | **Agent Framework Integration** | OpenClaw, JiuwenClaw built-in | LangChain native | Transformers agents | Varies | | **Open Source** | ✅ MIT License | ✅ | ✅ | Varies | **The verdict:** LangChain Hub excels for prompt templates within the LangChain ecosystem. Hugging Face dominates model distribution. But **SkillNet is the only platform treating skills as complete, evaluable, relational packages** with infrastructure for the entire lifecycle. If you need more than prompts—if you need capabilities that install, compose, and improve autonomously—SkillNet has no direct competitor. ## Frequently Asked Questions **Is SkillNet free to use?** Yes. Search and download operations require no API key and have no usage limits. Creation, evaluation, and analysis require an LLM API key (OpenAI-compatible), but you control the provider and costs. **What programming languages does SkillNet support?** The SDK is Python 3.9+. Skills themselves can wrap any executable code—Python, JavaScript, shell scripts, or compiled binaries. The package structure is language-agnostic. **Can I use SkillNet with private GitHub repositories?** Absolutely. Configure `GITHUB_TOKEN` with appropriate repository permissions. Private repos work for both skill creation (auto-generate from your code) and skill download (distribute within your organization). **How does the 5D evaluation handle safety?** The safety dimension tests for harmful outputs, prompt injection vulnerabilities, and policy violations using automated red-teaming. It doesn't replace human review for high-risk applications but catches common failure modes. **What's the difference between keyword and vector search?** Keyword search uses fuzzy text matching—fast, predictable, good for known skill names. Vector search embeds your query and skills into semantic space, finding relevant capabilities even with vocabulary mismatches. Use keyword for exploration, vector for discovery. **Can I contribute my own skills?** Yes—visit [skillnet.openkg.cn](http://skillnet.openkg.cn/), navigate to Contribute, and submit via URL, local upload, or batch upload. All contributions benefit from automatic relationship discovery and community evaluation. **Does SkillNet work offline?** Search requires internet access to query the public index. Downloaded skills run entirely locally. The analyze command works offline on your local skill directory. ## Conclusion: The Future of Agent Development is Composable SkillNet represents a fundamental shift in how we build AI systems. Instead of monolithic agents that grow unwieldy and redundant, we get **composable intelligence**—specialized capabilities that discover, evaluate, and combine themselves. The platform's 400,000+ skill library, auto-creation pipelines, and quality infrastructure solve problems that have plagued agent development since its inception. What impresses most is the **ecosystem momentum**. MCP server integration brings skills into mainstream IDEs. OpenClaw and JiuwenClaw integrations make skill operation autonomous. The free public API removes adoption friction entirely. This isn't a research prototype—it's production infrastructure with real integrations and active maintenance. My recommendation? **Start with search and download today** (zero setup), then progressively adopt creation and evaluation as your needs grow. If you're building agents in 2026, building without SkillNet is choosing to work harder, not smarter. ⭐ **[Star SkillNet on GitHub](https://github.com/zjunlp/SkillNet)** for the latest updates, and explore the [interactive demo](http://skillnet.openkg.cn/) to see skill discovery in action. Your future self—composing complex agents from battle-tested community capabilities in minutes—will thank you.]]>Mohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-building-ai-agents-from-scratch-use-skillnet-insteadTue, 27 Oct 2026 04:00:00 +0100https://converter.brightcoding.dev/blog/stop-wasting-your-llm-budget-nightshift-finds-dead-code-overnightMohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-wasting-your-llm-budget-nightshift-finds-dead-code-overnightTue, 27 Oct 2026 03:06:00 +0100https://converter.brightcoding.dev/blog/stop-writing-cuda-by-hand-taichi-compiles-python-into-gpu-kernelsMohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-writing-cuda-by-hand-taichi-compiles-python-into-gpu-kernelsTue, 27 Oct 2026 02:03:00 +0100https://converter.brightcoding.dev/blog/stop-clicking-in-n8n-ui-code-your-workflows-with-n8n-as-code` — fetch from n8n instance to repository - `n8nac push --verify` — push to n8n with validation - `n8nac resolve --mode keep-current` — handle conflicts deliberately Workflow source lives in Git. Diffs are meaningful. Rollbacks are `git revert`. This is how infrastructure should be managed. ### TypeScript Workflow Authoring The `@n8n-as-code/transformer` package converts opaque JSON workflows into **readable, typed TypeScript classes** with decorators: ```typescript @workflow({ id: 'abc123', name: 'Slack Notifier', active: true }) export class SlackNotifierWorkflow { @node() Trigger = { /* ... */ }; @node() Slack = { /* ... */ }; @links([{ from: 'Trigger', to: 'Slack' }]) connections = {}; } ``` Humans read and edit this. Agents generate it. The transformer compiles back to n8n-native JSON. Everyone wins. ### Live n8n Operations Connect to configured environments and perform real operations: verify workflow validity, inspect credentials (safely), run tests, activate/deactivate workflows, and inspect execution history. The `n8n-manager` subsystem handles local Docker instances, tunnels for remote access, and lifecycle management—keeping machine-local secrets separate from repository configuration. --- ## Real-World Use Cases Where n8n-as-code Shines ### 1. AI-Agent-Driven Workflow Development **The scenario**: Your product team needs a new customer onboarding automation—create CRM record, send welcome email, provision trial, notify Slack. Previously: you spend 2 hours in the n8n UI, or worse, explain the requirement to a developer who doesn't know n8n. **With n8n-as-code**: You prompt Claude Code: *"Build a customer onboarding workflow using HubSpot, SendGrid, and Slack nodes. Validate it against our Dev environment and push when tests pass."* The `n8n-architect` skill handles workspace setup, schema validation, safe node selection, and explicit sync. The workflow emerges as a reviewed, tested TypeScript file in your repository. **Development time: 15 minutes. Confidence: significantly higher.** ### 2. Multi-Environment GitOps Pipelines **The scenario**: You run n8n in development, staging, and production. Currently, promoting workflows means manual export/import, praying nothing breaks, and zero rollback capability. **With n8n-as-code**: Each environment is explicitly configured via `n8nac env add`. Workflows live in Git with environment-specific folders. Your CI pipeline runs `n8nac skills validate` on pull requests, `n8nac push --verify` to staging on merge, and production promotion requires explicit approval with full diff review. **Deployments become boring. This is the goal.** ### 3. Team Collaboration with Code Review **The scenario**: Three team members modify the same critical billing workflow. In the UI, last-save-wins silently destroys someone's changes. In JSON exports, diffs are unreadable and merge conflicts are unresolvable. **With n8n-as-code**: TypeScript workflow files produce **meaningful diffs**. Code review in GitHub/GitLab becomes possible. The `@links` decorator makes connection changes explicit. Merge conflicts? Resolve them with standard tools, with validation catching structural errors before they reach n8n. ### 4. Disaster Recovery and Audit Compliance **The scenario**: Your n8n instance crashes. Or worse, an auditor asks for change history on financial automation workflows. **With n8n-as-code**: Every workflow change is a Git commit with author, timestamp, and diff. `git log -- workflows/production/` tells the complete story. Recovery is `git checkout` plus `n8nac push`. Compliance becomes documentation generation, not forensic archaeology. --- ## Step-by-Step Installation & Setup Guide ### Prerequisites - Node.js 18+ and npm - VS Code or Cursor (for editor integration) - An n8n instance (cloud, self-hosted, or local via `n8n-manager`) - n8n API key for your instance ### VS Code / Cursor Extension (Recommended) The fastest path to productivity: ```bash # Install via VS Code Marketplace or Open VSX # Search: "n8n-as-code" by Etienne Lescot # Or install from command line: code --install-extension etienne-lescot.n8n-as-code ``` **Configuration steps:** 1. Open a folder or `.code-workspace` in VS Code/Cursor 2. Click the n8n-as-code extension icon in the sidebar 3. Click the gear icon to open workspace configuration 4. Create or select an **n8n environment**: - For existing n8n: provide base URL and API key - For new local instance: use `n8n-manager` integration 5. Set your **sync folder** (e.g., `workflows/dev`) 6. Pull existing workflows or create new ones via the Agent Workbench The configuration UI mirrors the CLI model: workspace environments are repository context, local managed instances are machine resources. ### CLI-First Setup For terminal enthusiasts and CI/CD integration: ```bash # Install and run n8nac via npx (no global install needed) npx --yes n8nac env add Dev \ --base-url https://n8n.example.com \ --sync-folder workflows/dev # Authenticate securely via stdin (avoids shell history) printf '%s' "$N8N_API_KEY" | npx --yes n8nac env auth set Dev --api-key-stdin # Activate this environment npx --yes n8nac env use Dev # Generate AI context for your workspace npx --yes n8nac update-ai ``` **Local managed instance alternative:** ```bash # List available local instances n8n-manager instance list # Create and configure new environment from local instance npx --yes n8nac env add Local \ --managed-instance \ --sync-folder workflows/local npx --yes n8nac env use Local ``` ### Your First Sync ```bash # List workflows on the connected n8n instance npx --yes n8nac list # Pull a specific workflow to your repository npx --yes n8nac pull # Edit the pulled .workflow.ts file, then push with validation npx --yes n8nac push workflows/dev/my-workflow.workflow.ts --verify ``` **Critical**: Sync is always explicit. Nothing happens unless you command it. This is the GitOps contract. ### Environment Variables for CI/CD ```bash # In your CI environment, set: export N8N_API_KEY="n8n_api_..." export N8N_BASE_URL="https://n8n.production.company.com" # Then run validation and deployment npx n8nac env use Production npx n8nac skills validate workflows/production/ npx n8nac push workflows/production/critical.workflow.ts --verify ``` --- ## REAL Code Examples from the Repository The n8n-as-code repository contains production-ready code patterns that demonstrate its power. Here are the essential examples, extracted directly from the documentation and explained in depth. ### Example 1: TypeScript Workflow Definition This is the flagship feature—workflows as decorated TypeScript classes. The following example creates a webhook-triggered Slack notification, directly from the repository README: ```typescript import { workflow, node, links } from '@n8n-as-code/transformer'; // The @workflow decorator defines workflow-level metadata // id: stable identifier for sync operations // name: human-readable display name in n8n UI // active: whether the workflow starts enabled @workflow({ id: 'abc123', name: 'Slack Notifier', active: true }) export class SlackNotifierWorkflow { // @node() marks a property as a workflow node // Each property becomes a node in the n8n canvas @node() Trigger = { // type: the n8n node type identifier (from 537 available schemas) type: 'n8n-nodes-base.webhook', // parameters: node-specific configuration with full type safety parameters: { path: '/notify', // webhook URL path method: 'POST', // HTTP method to accept }, // position: [x, y] coordinates for canvas layout position: [250, 300], }; @node() Slack = { type: 'n8n-nodes-base.slack', parameters: { resource: 'message', // Slack API resource operation: 'post', // CRUD operation channel: '#alerts', // target channel // Expression syntax: '={{ $json.message }}' references previous node output text: '={{ $json.message }}', // dynamic content from webhook payload }, position: [450, 300], }; // @links() defines connections between nodes // Creates the execution flow: Trigger → Slack @links([{ from: 'Trigger', to: 'Slack' }]) connections = {}; // populated by decorator, empty object as placeholder } ``` **Why this matters**: The TypeScript format is **diffable**, **type-checkable**, and **AI-friendly**. Compare this to n8n's native JSON, where a simple workflow spans 200+ lines of nested objects with cryptic IDs. Here, the structure is self-documenting. Your IDE provides autocomplete for node types and parameters. Code review becomes trivial. And AI agents can generate this pattern reliably because it's standard TypeScript with clear conventions. ### Example 2: Environment Configuration and Authentication The CLI provides explicit, secure environment management. These commands from the README establish the foundation for all operations: ```bash # Add a production environment with explicit sync folder # --base-url: your n8n instance URL # --sync-folder: local directory for workflow files n8nac env add Dev --base-url https://n8n.example.com --sync-folder workflows/dev # Authenticate using stdin to prevent API key exposure in shell history # $N8N_API_KEY should be set as an environment variable printf '%s' "$N8N_API_KEY" | n8nac env auth set Dev --api-key-stdin # Select the active environment for subsequent commands n8nac env use Dev # Verify configuration n8nac env list ``` **Security insight**: The `--api-key-stdin` pattern is deliberate. API keys never appear in `ps` output, shell history, or process listings. This aligns with the project's principle that **secrets stay local**—machine-local runtime state never contaminates the repository. ### Example 3: AI Skills Query and Validation The skills layer is what truly differentiates n8n-as-code for AI-agent workflows. These commands demonstrate how agents (or developers) query structured n8n knowledge: ```bash # Search across 7,700+ templates and node documentation # Returns structured results with node types, parameters, and examples npx --yes n8nac skills search "send slack message when google sheet is updated" # Get detailed schema information for a specific node # Includes all parameters, valid values, defaults, and descriptions npx --yes n8nac skills node-info slack # Validate a TypeScript workflow file against live schemas # Catches errors before push: missing required params, invalid values, broken connections npx --yes n8nac skills validate workflows/dev/my-workflow.workflow.ts ``` **Agent integration**: When Claude Code uses the `n8n-architect` skill, these commands execute transparently. The agent doesn't hallucinate node parameters—it queries authoritative schemas. It doesn't guess connection validity—it validates structurally. This **grounded knowledge** is what makes n8n-as-code safe for autonomous agent operation. ### Example 4: Bidirectional Sync Operations The GitOps sync model is demonstrated through these explicit commands: ```bash # Switch to the Dev environment context n8nac env use Dev # List workflows available on the remote n8n instance n8nac list # Pull a specific workflow by ID into your sync folder # Creates or updates the .workflow.ts file n8nac pull # After editing, push back with verification # --verify: runs validation before push, prevents broken workflows in production n8nac push workflows/dev/my-workflow.workflow.ts --verify # Conflict resolution: when local and remote diverge # --mode keep-current: preserve local version, discard remote changes n8nac resolve --mode keep-current ``` **Operational discipline**: Notice the explicit verbs—`pull`, `push`, `resolve`. There's no automatic sync, no background daemon. Every state change is intentional and auditable. This mirrors Git's design philosophy: explicit operations enable safe collaboration. ### Example 5: Batch TypeScript Conversion For existing n8n users with workflow libraries, the transformer enables bulk migration: ```bash # Convert a single JSON workflow to TypeScript n8nac convert workflow.json --format typescript # Batch convert entire directory structures # Preserves organization, generates consistent naming n8nac convert-batch workflows/ --format typescript ``` **Migration strategy**: Run `convert-batch` on your existing exports, commit the TypeScript files, then gradually replace manual UI edits with code-driven workflows. The `--format` flag anticipates future output formats, future-proofing your automation investment. --- ## Advanced Usage & Best Practices ### Workspace Migration Strategy Upgrading from V1? The migration path is deliberate and safe: ```bash # Dry-run: see all operations without applying n8nac workspace migrate --json # Review the JSON output, then apply n8nac workspace migrate --write ``` Always run `--json` first. The unified `operations` list shows exactly what changes across legacy workspace and global instance configurations. ### Local Development with n8n-manager For isolated development without cloud dependencies: ```bash # Create, start, and tunnel a local n8n instance n8n-manager instance create n8n-manager instance start n8n-manager tunnel start # expose via public URL for webhook testing ``` **Critical separation**: `n8n-manager` handles machine-local operations only. Never use it as workspace source of truth—that's `n8nac env`'s role. ### AI Agent Optimization For maximum agent effectiveness: 1. **Run `n8nac update-ai`** after adding new environments or updating n8n versions—this regenerates the grounded context 2. **Use explicit sync folders per environment** (`workflows/dev`, `workflows/staging`, `workflows/production`) to prevent accidental cross-environment pushes 3. **Validate before every push**—the `--verify` flag is your safety net 4. **Commit `.workflow.ts` files, never `.json`**—TypeScript is your source of truth; JSON is build output ### CI/CD Integration Pattern ```yaml # .github/workflows/n8n-deploy.yml - name: Validate Workflows run: | npx n8nac env use Staging npx n8nac skills validate workflows/staging/ - name: Deploy to Staging if: github.ref == 'refs/heads/main' run: | npx n8nac push workflows/staging/ --verify ``` --- ## Comparison with Alternatives | Capability | n8n Native Export/Import | Third-Party Backup Tools | **n8n-as-code** | |:---|:---|:---|:---| | **Version Control** | Manual JSON blobs, unreadable diffs | Scheduled backups, no diff | **Native Git, meaningful TypeScript diffs** | | **Code Review** | Impossible | N/A | **Full PR review with line comments** | | **AI Agent Integration** | None | None | **Structured skills, schema grounding, safe operations** | | **Type Safety** | None | None | **TypeScript decorators, compile-time validation** | | **Multi-Environment** | Manual, error-prone | Single-target | **Explicit `n8nac env` with per-environment sync** | | **Editor Integration** | Browser-only | N/A | **VS Code/Cursor native, sidebar, canvas, Agent Workbench** | | **Rollback** | Manual restore from backup | Point-in-time restore | **`git revert`, instant, auditable** | | **CI/CD Integration** | Custom scripts | N/A | **First-class CLI, validation, verify-before-push** | | **Community Templates** | Browse in UI | N/A | **7,700+ searchable via `n8nac skills search`** | | **Node Schema Coverage** | UI exploration | N/A | **537 nodes with complete programmatic schemas** | **The verdict**: n8n-as-code isn't competing with n8n—it's completing it. For solo hobbyists, the visual editor remains fine. For teams, regulated industries, AI-agent workflows, or any scenario where **confidence, auditability, and scale** matter? There's no meaningful alternative. --- ## FAQ ### Is n8n-as-code officially supported by n8n? **No—and that's explicitly stated.** n8n-as-code is an independent community project under MIT license. It's not affiliated with, endorsed by, or sponsored by n8n GmbH. However, it builds against n8n's public APIs and maintains compatibility with latest stable releases. ### Will this break my existing n8n workflows? **No.** n8n-as-code operates bidirectionally. Your existing workflows remain untouched in n8n. Pull them to start, edit in TypeScript, push back with `--verify` validation. The native JSON format is always the interchange standard—TypeScript is a developer-friendly layer above it. ### Do I need to learn TypeScript to use this? **Not necessarily.** The VS Code extension provides visual editing. AI agents can generate TypeScript from natural language. But if you *do* know TypeScript, you gain diffability, IDE autocomplete, and structural validation that JSON cannot provide. ### How does the AI agent know what nodes to use? **Grounded knowledge via skills.** The `n8n-architect` skill embeds 537 node schemas, 7,700+ templates, validation rules, and safe operation patterns. When your agent asks "how do I send email?", it receives structured, authoritative information—not hallucinated guesses. ### Can I use this with n8n Cloud? **Yes.** Any n8n instance with API access works: n8n Cloud, self-hosted, or local `n8n-manager` instances. Just configure the base URL and API key via `n8nac env add`. ### What happens when n8n releases new nodes? **Run `n8nac update-ai`.** The bundled node schema is built against latest stable n8n. Keeping your n8n instance updated ensures best generation and validation results. The project tracks n8n releases actively. ### Is the sync automatic or manual? **Explicitly manual.** This is a feature, not a limitation. `n8nac pull` and `n8nac push` require intentional execution. Nothing syncs automatically, preventing accidental overwrites and enabling GitOps review workflows. --- ## Conclusion The future of workflow automation isn't in browser tabs. It's in repositories, code reviews, and AI-agent collaborations that happen while you focus on higher-order problems. **[n8n-as-code](https://github.com/EtienneLescot/n8n-as-code)** represents a fundamental shift: n8n workflows become **code**, with all the tooling, governance, and AI accessibility that implies. The 537 node schemas, 7,700+ templates, GitOps sync, and TypeScript authoring aren't features in isolation—they're components of a cohesive developer experience that n8n alone cannot provide. My assessment? If you're running n8n in production, collaborating with a team, or experimenting with AI agents for automation development, n8n-as-code isn't optional—it's **corrective infrastructure**. It fixes the structural gaps that become painful at scale. The project is MIT-licensed, actively maintained, and ready for your workflows. Install the [VS Code extension](https://marketplace.visualstudio.com/items?itemName=etienne-lescot.n8n-as-code), grab the CLI with `npx n8nac`, or point Claude Code at the [repository skills](https://github.com/EtienneLescot/n8n-as-code/tree/main/skills). Your future self—reviewing a clean TypeScript diff at 3 PM instead of debugging a canvas at 3 AM—will thank you. **[Star n8n-as-code on GitHub](https://github.com/EtienneLescot/n8n-as-code) → Explore the [documentation](https://n8nascode.dev/) → Stop clicking. Start coding.**]]>Mohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-clicking-in-n8n-ui-code-your-workflows-with-n8n-as-codeTue, 27 Oct 2026 01:00:00 +0100https://converter.brightcoding.dev/blog/stop-struggling-with-math-animations-use-manim-insteadMohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-struggling-with-math-animations-use-manim-insteadTue, 27 Oct 2026 00:02:00 +0100https://converter.brightcoding.dev/blog/stop-losing-telegram-data-forever-telegram-scraper-exposedMohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-losing-telegram-data-forever-telegram-scraper-exposedMon, 26 Oct 2026 21:00:00 +0100https://converter.brightcoding.dev/blog/stop-wrestling-with-claude-codes-defaults-tweakcc-exposed-claude-code- ``` Remember: `nix-collect-garbage` or rebuilds will wipe patches. Simply re-run `sudo npx tweakcc --apply` to restore. ## REAL Code Examples: tweakcc in Action Let's examine actual code patterns from the repository, showing both CLI usage and programmatic API integration. ### Example 1: Basic Ad-Hoc String Replacement The simplest `adhoc-patch` usage replaces fixed strings throughout Claude Code's source: ```bash # Replace all instances of "Claude Code" with custom branding $ npx tweakcc adhoc-patch --string '"Claude Code"' '"My App"' # Replace only the second occurrence using --index $ npx tweakcc adhoc-patch --string 'thinking' 'processing' --index 2 ``` This is analogous to `grep -F` but operates on the compiled JavaScript. The `--index` parameter is crucial when multiple occurrences exist and you need surgical precision. ### Example 2: Regex-Based Color Overhaul For pattern-based modifications, use regex mode with capture group replacement: ```bash # Replace all CSS-style RGB colors with bright red $ npx tweakcc adhoc-patch --regex 'rgb\(\d+,\d+,\d+\)' 'rgb(255,0,0)' # More complex: replace Claude Code references with capture groups $ npx tweakcc adhoc-patch --regex '/Claude (Code|Agent)/g' 'My $1' ``` The regex must use JavaScript-style forward slash delimiters with optional flags (`g`, `i`, `m`, `s`, `u`, `y`). The `$D` syntax references capture groups—`$0` for full match, `$1` for first group, etc. ### Example 3: Sandboxed Script Patching (Most Powerful) For complex modifications, sandboxed scripts receive Claude Code's JavaScript as a global `js` variable and return modified content: ```js // Simple replacement script js = js.replace(/"Claude Code"/g, '"My App"'); return js; ``` For advanced patches needing Claude's internal variables, the `vars` global provides minified identifier mappings: ```js // Access common internal variables for sophisticated patches const vars = { chalkVar: 'K6', // Color/styling utility moduleLoaderFunction: 's', // Low-level module loader reactVar: 'Yt8', // React instance requireFuncName: 'C1', // require() implementation textComponent: 'f', // Ink component boxComponent: 'NZ5', // Ink component }; // Example: Inject feature flag bypass const pattern = /function [\$\w]+\(\)\{return [\$\w]+\("my_feature_flag"/; const match = js.match(pattern); if (match) { const insertIndex = match.index + match[0].indexOf('{') + 1; js = js.slice(0, insertIndex) + 'return true;' + js.slice(insertIndex); } return js; ``` Execute via: ```bash # Inline script $ npx tweakcc adhoc-patch --script $'return js.replace(/Claude Code/g, "ABC Code CLI")' # From local file $ npx tweakcc adhoc-patch --script '@path/to/script.js' # From remote URL (sandboxed but review the diff!) $ npx tweakcc adhoc-patch --script '@https://gist.githubusercontent.com/user/gist-id/raw/patch.js' ``` ### Example 4: Programmatic API for Custom Tools Version 4.0.0's API enables building custom tools around tweakcc: ```javascript const tweakcc = require('tweakcc'); const path = require('path'); const os = require('os'); async function customizeClaudeCode() { // Discover all installations const installations = await tweakcc.findAllInstallations(); console.log('Found installations:', installations); // Auto-detect preferred installation const inst = await tweakcc.tryDetectInstallation({ interactive: true }); // Read current JavaScript content (handles both npm and native) let content = await tweakcc.readContent(inst); console.log(`Content size: ${content.length} bytes`); // Inspect system prompt strings const promptSnippet = content.slice(4153122, 4153122 + 236); console.log('Prompt snippet:', promptSnippet); // Modify content content = content.replace(/Claude Code/g, 'My App'); content = content.replace(/Anthropic(?: PBC)?/g, 'My Corp'); // Create backup before modifying const backupPath = path.join(os.homedir(), '.myapp', `cc-${inst.kind}-backup`); await tweakcc.backupFile(inst.path, backupPath); // Write modified content back await tweakcc.writeContent(inst, content); // Verify changes const newContent = await tweakcc.readContent(inst); const newSnippet = newContent.slice(4153122 + 16, 4153122 + 172); console.log('Modified snippet:', newSnippet); // Restore from backup if needed // await tweakcc.restoreBackup(backupPath, inst.path); } customizeClaudeCode().catch(console.error); ``` ### Example 5: Thinking Verbs Configuration From the README, here's the exact `config.json` structure for custom thinking verbs: ```json { "thinkingVerbs": { "format": "Claude is {verb}ing...", "verbs": [ "Accomplishing", "Baking", "Cogitating", "Fermenting", "Moonwalking", "Noodling" ] } } ``` The `{}` placeholder in `format` receives a randomly selected verb. Reset to 200+ default verbs anytime with `Ctrl+R` in the TUI. ## Advanced Usage & Best Practices **Version Pinning for Stability** — tweakcc verifies against specific Claude Code versions (currently 2.1.62). Non-system-prompt patches may break on updates. Pin your Claude Code version in team environments, or embrace the rapid update cycle and reapply after each update. **Git-Based Prompt Versioning** — Initialize a git repo in `~/.tweakcc`. The auto-generated `.gitignore` handles transient files. Branch per project or team, merge upstream prompt changes with tweakcc's HTML diff guidance. The repository [bl-ue/tweakcc-system-prompts](https://github.com/bl-ue/tweakcc-system-prompts) demonstrates this pattern. **Remote Config for Team Distribution** — Host validated configurations on GitHub Gists or internal pastes. Team members apply with `--config-url` for instant, identical environments. Your local config isn't overwritten—remote settings merge under `remoteConfig.settings`. **Sandboxed Script Safety** — The `--script` mode uses Node.js 20+'s `--experimental-permission` flag, blocking filesystem and network APIs within the patch script itself. However, the *output* patches Claude Code's executable, so **always review the diff** tweakcc prints before confirming. **Backup Hygiene** — tweakcc maintains `~/.tweakcc/cli.backup.js` or `~/.tweakcc/native-binary.backup`. If you manually modify Claude Code without tweakcc's knowledge, then run tweakcc, it may backup your already-modified version. Break this loop by reinstalling Claude Code fresh, or manually deleting the backup file. ## Comparison with Alternatives | Feature | tweakcc | lobotomized-claude-code | Manual Patching | Claude Code Native | |---------|---------|------------------------|-----------------|-------------------| | **System Prompt Editing** | ✅ Full dynamic composition | ✅ Static overrides | ⚠️ Fragile, breaks on update | ❌ Not possible | | **UI Theming** | ✅ HSL/RGB picker, spinners, verbs | ❌ None | ❌ None | ❌ None | | **Toolsets** | ✅ Remove tools from context | ❌ No | ❌ No | ❌ No | | **Auto-Reapply on Update** | ✅ `--apply` restores all | ❌ Manual | ❌ Manual | N/A | | **Native Binary Support** | ✅ node-lief extraction | ❌ npm only | ⚠️ Complex | N/A | | **MCP Optimization** | ✅ Non-blocking, batch size | ❌ No | ❌ No | ❌ No | | **Programmatic API** | ✅ Full Node.js API | ❌ No | ❌ No | ❌ No | | **Ad-Hoc Patching** | ✅ Sandboxed scripts | ❌ No | ⚠️ Risky | ❌ No | | **Conflict Resolution** | ✅ HTML diff visualization | ❌ Manual | ❌ Manual | N/A | | **AGENTS.md Support** | ✅ Automatic fallback | ❌ No | ❌ No | ❌ No | **lobotomized-claude-code** excels for Opus 4.7-specific prompt tuning but lacks tweakcc's infrastructure. **Manual patching** is educational but unsustainable. **tweakcc** is the only comprehensive platform supporting both npm and native installations with automatic lifecycle management. ## FAQ: Your Burning Questions Answered **Q: Will tweakcc break when Anthropic updates Claude Code?** A: Your customizations in `~/.tweakcc/config.json` survive updates. Run `npx tweakcc --apply` after any Claude Code update to reapply. System prompt patches work across versions if we have prompts for your version (we add them within minutes of releases). Non-prompt patches target verified versions but often continue working. **Q: Is modifying Claude Code's binary safe?** A: tweakcc creates automatic backups before any modification. The `--restore` flag reverts to original. For native binaries, we use established LIEF instrumentation techniques via node-lief, with ad-hoc code signing on Apple Silicon to prevent macOS security warnings. **Q: Can I use tweakcc with my team's shared configuration?** A: Absolutely. Host config JSON on any HTTP URL and apply with `--config-url`. For system prompts, version control `~/.tweakcc/system-prompts/` and share the repository. Future releases plan integrated git repo management. **Q: Does this work with Claude Code's native installer or only npm?** A: Both. Native installations use Bun-compiled binaries—we extract, patch, and repack the embedded JavaScript. This works on macOS (including Apple Silicon with ad-hoc signing), Windows, and Linux. Nix installations require `sudo` due to read-only store. **Q: What's the difference between toolsets and Claude's permission system?** A: Claude's permissions block tool *execution* but still send tool *descriptions* to the model, consuming context. tweakcc toolsets completely remove disabled tools from the system prompt—Claude doesn't know they exist, saving thousands of tokens. **Q: Can I create completely custom patches without forking tweakcc?** A: Yes! Version 4.0.0's `adhoc-patch --script` runs sandboxed Node.js scripts against Claude Code's JavaScript. Host scripts on GitHub Gists for easy distribution. No fork, no PR, no waiting. **Q: Will this get my Claude Code account banned?** A: tweakcc modifies local installation files only—no network interception, no API manipulation, no terms-of-service violation. You're customizing software running on your own machine, similar to browser extensions or VS Code themes. ## Conclusion: Take Control of Your Claude Code Experience The days of accepting Claude Code exactly as Anthropic ships it are over. **tweakcc** represents a fundamental shift—from passive consumer to active curator of your AI development environment. Whether you're shaving seconds off MCP startup, crafting the perfect system prompt for your codebase, or simply making your terminal reflect your personality, this tool delivers capabilities that should have been built-in from day one. What strikes me most after deep exploration: this isn't just customization for customization's sake. The `opusplan[1m]` alias genuinely solves context anxiety. Non-blocking MCP startup measurably improves workflow rhythm. Toolsets materially reduce token costs. These are **productivity multipliers disguised as nice-to-haves**. The Piebald team's engineering rigor shows in every detail—from sandboxed script execution to HTML diff visualization to Nix wrapper detection. This is infrastructure-grade tooling released as open source. Your move. The repository is live at [github.com/Piebald-AI/tweakcc](https://github.com/Piebald-AI/tweakcc). Star it, install it with `npx tweakcc`, and discover what Claude Code was always meant to be. Your perfect terminal AI assistant is one `--apply` away. **Don't just use Claude Code. Own it.**]]>Mohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-wrestling-with-claude-codes-defaults-tweakcc-exposedMon, 26 Oct 2026 21:00:00 +0100https://converter.brightcoding.dev/blog/stop-building-ai-agents-from-scratch-use-anygen-skills-instead None: """Persist configuration to JSON store""" config = self._load() config[key] = value with open(self.CONFIG_FILE, 'w') as f: json.dump(config, f) print(f"Set {key} (value hidden for security)") def get(self, key: str) -> str | None: """Retrieve with environment variable override""" env_key = f"ANYGEN_{key.upper()}" if env_value := os.getenv(env_key): return env_value # Environment takes precedence return self._load().get(key) def _load(self) -> dict: if self.CONFIG_FILE.exists(): return json.loads(self.CONFIG_FILE.read_text()) return {} ``` **Critical insight**: The environment variable override (`ANYGEN_API_KEY`) enables CI/CD pipelines without committing secrets. The CLI store is for developer convenience; environment injection is for production safety. ### Example 3: Natural Language Skill Invocation The README demonstrates conversational skill triggering. Here's how you'd implement this in an OpenClaw agent: ```python # agent_orchestrator.py - Integration pattern for AnyGen Skills import subprocess import json from typing import Optional class AnyGenSkillExecutor: def __init__(self, skills_base_path: str = "~/.openclaw/skills/anygen"): self.skills_path = Path(skills_base_path).expanduser() self.skill_map = { "presentation": "slide-generator", "document": "doc-generator", "diagram": "diagram-generator", "research": "deep-research", "financial": "financial-research", "image": "image-generator", "storybook": "storybook-generator", "website": "website-generator", "data": "data-analysis" } def execute(self, natural_command: str) -> dict: """ Parse natural language and route to appropriate skill. Examples: "Make a product roadmap PPT" -> slide-generator "Analyze NVIDIA's latest earnings" -> financial-research """ skill_name = self._detect_skill(natural_command) skill_path = self.skills_path / skill_name / "scripts" / "anygen.py" if not skill_path.exists(): raise SkillNotFoundError(f"{skill_name} not installed") # Execute skill with quoted command to preserve spaces result = subprocess.run( ["python3", str(skill_path), "generate", natural_command], capture_output=True, text=True, env={**os.environ, "ANYGEN_API_KEY": self._get_api_key()} ) return { "skill": skill_name, "command": natural_command, "output": result.stdout, "artifacts": self._collect_artifacts(skill_name) } def _detect_skill(self, command: str) -> str: """Simple keyword-based routing; production would use LLM classification""" command_lower = command.lower() for keyword, skill in self.skill_map.items(): if keyword in command_lower: return skill return "doc-generator" # Default fallback def _collect_artifacts(self, skill_name: str) -> list[str]: """Find generated files in skill's output directory""" output_dir = self.skills_path / skill_name / "output" if output_dir.exists(): return [str(f) for f in output_dir.iterdir() if f.is_file()] return [] ``` **Production consideration**: This routing is intentionally simple. For production agents, replace `_detect_skill` with an LLM-based classifier that handles ambiguous queries like "Create a visual summary of Q3 financials" (could be diagram, presentation, or document). ### Example 4: Project Structure Navigation Understanding the directory layout enables programmatic skill management: ```python # skill_manager.py - Dynamic skill discovery and loading from pathlib import Path from dataclasses import dataclass @dataclass class SkillInfo: name: str description: str has_script: bool script_path: Optional[Path] class SkillRegistry: SKILL_DESCRIPTIONS = { "slide-generator": "Professional PPT/presentation generation", "doc-generator": "Document and report generation", "diagram-generator": "Diagrams, flowcharts, architecture diagrams (SmartDraw)", "data-analysis": "Data analysis and visualization", "deep-research": "Long-form research reports", "financial-research": "Earnings and financial analysis", "image-generator": "Design Images and visual assets", "storybook-generator": "Visual narratives and Storybook", "website-generator": "Landing pages and web development" } def __init__(self, base_path: str = "~/.openclaw/skills/anygen"): self.base = Path(base_path).expanduser() def discover(self) -> list[SkillInfo]: """Scan installed skills and report capabilities""" skills = [] for skill_dir in sorted(self.base.iterdir()): if not skill_dir.is_dir() or skill_dir.name.startswith('.'): continue script = skill_dir / "scripts" / "anygen.py" skills.append(SkillInfo( name=skill_dir.name, description=self.SKILL_DESCRIPTIONS.get(skill_dir.name, "Unknown skill"), has_script=script.exists(), script_path=script if script.exists() else None )) return skills def install_status(self) -> dict: """Compare available vs installed skills""" installed = {s.name for s in self.discover()} available = set(self.SKILL_DESCRIPTIONS.keys()) return { "installed": list(installed), "missing": list(available - installed), "coverage": f"{len(installed)}/{len(available)}" } ``` --- ## Advanced Usage & Best Practices **Skill Composition Patterns**: Combine multiple skills for complex workflows. A quarterly business review might chain `financial-research` → `data-analysis` → `slide-generator`. Orchestrate with a lightweight state machine: ```python # Sequential skill pipeline pipeline = [ ("financial-research", "Analyze Q3 earnings for {company}"), ("data-analysis", "Visualize revenue trends from {previous_output}"), ("slide-generator", "Create executive summary presentation with {charts}") ] ``` **Prompt Engineering at the Skill Level**: Each skill accepts natural language, but precision matters. Instead of "Make a presentation," try "Generate a 12-slide Series B fundraising deck with market size, traction metrics, and team bios." The AnyGen API likely uses structured prompting internally; your specificity propagates through. **Output Artifact Management**: Skills generate files in their local directories. Implement a centralized artifact store: ```bash # Daily cron to sync outputs to S3 find ~/.openclaw/skills/anygen/*/output -type f -mtime -1 \ | xargs -I {} aws s3 cp {} s3://company-anygen-artifacts/$(date +%Y%m%d)/ ``` **Version Pinning for Reproducibility**: The `git clone` pulls latest main. For production stability, pin to releases: ```bash git clone --branch v1.2.3 --depth 1 https://github.com/AnyGenIO/anygen-skills.git ``` **Custom Skill Development**: Fork existing skills as templates. The `doc-generator` structure—`scripts/anygen.py`, `templates/`, `output/`—provides a blueprint for internal skills (e.g., `compliance-generator`, `incident-report-generator`). --- ## Comparison: AnyGen Skills vs. The Alternatives | Dimension | AnyGen Skills | Monolithic SaaS (Jasper, Copy.ai) | Custom GPT Wrappers | LangChain Agents | |-----------|-------------|-----------------------------------|---------------------|------------------| | **Modularity** | ✅ Install per-skill | ❌ All-or-nothing platform | ⚠️ Build from scratch | ⚠️ Requires orchestration code | | **Agent Integration** | ✅ Native OpenClaw/Claude/Cursor | ❌ External API calls | ⚠️ Manual integration | ✅ Framework-native | | **Output Quality** | ✅ Domain-optimized (SmartDraw, etc.) | ⚠️ Generic templates | ❌ Depends on your prompts | ❌ Depends on your prompts | | **Data Privacy** | ✅ Self-hosted agent, API-only content | ❌ Cloud-hosted everything | ✅ Fully self-hosted | ✅ Fully self-hosted | | **Setup Time** | ✅ 5 minutes | ✅ Instant signup | ❌ Days to weeks | ❌ Hours to days | | **Customization** | ✅ Fork and modify skills | ❌ Limited styling | ✅ Unlimited | ✅ Unlimited | | **Cost Model** | API usage only | Subscription + usage | Infrastructure + API | Infrastructure + API | | **Learning Curve** | Low | Low | High | High | **Verdict**: AnyGen Skills occupies a sweet spot—faster than custom builds, more flexible than SaaS prisons, purpose-built for agent workflows unlike general frameworks. --- ## FAQ: What Developers Actually Ask **Q: Do I need OpenClaw specifically, or will this work with my custom agent?** A: The skills are Python scripts with standard interfaces. While paths default to OpenClaw/Claude/Cursor conventions, you can invoke `anygen.py` directly from any Python environment. The agent integration is convenience, not requirement. **Q: Is the AnyGen API free?** A: The repository requires an API key from [anygen.io](https://www.anygen.io/home?auto_create_openclaw_key=1). Pricing isn't disclosed in the README—expect usage-based billing typical for content generation APIs. The MIT license covers the skills code, not the backend service. **Q: Can I run this entirely offline?** A: No. The skills call AnyGen's API for generation. For fully offline operation, you'd need to replace the API client with local LLM inference (Ollama, vLLM)—a significant fork. **Q: How do I add a custom skill not in the nine provided?** A: Study the structure of existing skills: `scripts/anygen.py` for CLI interface, `templates/` for output formatting, `output/` for artifacts. The `anygen-suite-skill` may reveal composition patterns. There's no formal SDK yet—copy and adapt. **Q: What's the difference between individual skills and `anygen-suite-skill`?** A: Individual skills are standalone repositories you clone. `anygen-suite-skill` (installable via `clawhub install anygen-skill`) bundles all functionality with unified versioning. Use individual skills for selective deployment; use suite for simplicity. **Q: Are generated outputs commercially usable?** A: The MIT license covers the skill code. Output ownership depends on AnyGen's terms of service—standard practice suggests you own generated content, but verify for high-stakes commercial use. **Q: How does this compare to Claude's native artifacts or Code Interpreter?** A: Native features are general-purpose. AnyGen Skills are *specialized*—the `financial-research` skill embeds analyst expertise that generic tools lack. Use both: native for exploration, skills for production deliverables. --- ## Conclusion: The Modular Future Is Already Here I started this article with a painful truth: most AI agent developers are wasting time on infrastructure that should be commoditized. AnyGen Skills is the commoditization happening in real-time. The repository at [github.com/AnyGenIO/anygen-skills](https://github.com/AnyGenIO/anygen-skills) isn't perfect—documentation is sparse, error handling could be richer, and the API dependency creates a vendor relationship. But it's **directionally correct** in ways that matter. Modular skills. Natural language interfaces. Professional outputs. Five-minute setup. If you're building agentic workflows in 2024, you have three options: wrestle with LangChain abstractions, surrender to SaaS platforms that own your data, or adopt composable skill architectures like AnyGen. I've done all three. The third path is where velocity lives. **Your move**: Clone the repository. Set your API key. Generate something real in the next ten minutes. The skills are waiting. Your competitors aren't. ```bash git clone https://github.com/AnyGenIO/anygen-skills.git ~/.openclaw/skills/anygen export ANYGEN_API_KEY="sk-your-key-here" # Now tell your agent: "Make something impressive" ``` *Star the repo if it saves you a day. Fork it if you can make it better. The agent ecosystem needs more builders, more experimenters, more people shipping instead of configuring.*]]>Mohamed IDBRAHIMhttps://converter.brightcoding.dev/blog/stop-building-ai-agents-from-scratch-use-anygen-skills-insteadMon, 26 Oct 2026 17:00:00 +0100