Software & DevOps

The author added an opt-in showcase to the netscript CLI: `netscript init northwind --from showcase`, plus a documented `showcase:setup` recipe. The showcase composes existing Util

On the field-work-hub repo, the author implemented approved Phases 5 and 6 together in dependency order on the draft branch feat/phase-5-6-dashboard-workflow. The dashboard was rew

The author added `.github/workflows/release.yml` to the openarena repo, publishing the package with PyPI Trusted Publishing (OIDC, no stored secrets). The workflow triggers on `rel

The author added an `api/evals/` directory containing a fixed golden-question suite for the app's chat agent, closing out known-issue #14 ("no automated tests") in `docs/ARCHITECTU

The author opened a scoped connector-migration issue in the okou-ai/okou repo, as a native child of a larger HTTP-to-MCP shortlist (#36738). They identified the existing `algolia`

The author's `/dev` carrier — a sandboxed `claude` CLI invocation defined in spec/005 — could only authenticate via `ANTHROPIC_API_KEY`. On a machine with only a Claude Code subscr

The author reworked how people directories and LDAP browsing are modelled in the ihub-apps integrations system. They renamed `com.intrafind/ldap-directory` to "People directory (LD

The author built the first half of a learning loop for a multi-harness agent server: the switch, the folder, and the seed every run starts from. Concretely: (1) a `learning: boolea

The author consolidated coding delegation and AI provider routing in the Fabric OSS repo around two surfaces: Fabric Agents Remote Server (fabric-agent-server) and Fabric Agents De

They were building an AI assistant UI where answers stream in token by token, and the existing Markdown renderer kept flickering: incomplete code fences, footnote definitions arriv

AiphaBee, a private downstream bot product, was upgrading from @byok-sdk/client 0.28.0 and wanted to replace its own agent-home memory writer with the SDK's memory_recall / memory_

They installed Chisle into a Claude Code repo with a single `npx chisle` command, which drops in a ruleset that suppresses filler, hedging and speculative abstractions, plus a Post

They wanted a production-grade inference path for a mixture-of-experts model on Hopper and Blackwell GPUs, and started from FlashInfer because it exposes unified APIs for attention

The author implemented removal of saved workflows from Kiro Crew's dashboard library as a tombstone rather than a hard delete. In workflows/library.py, removal writes a tombstone (

The author closed a Windows PATH-hijack hole in oh-my-claudecode (omc). An earlier fix (#4726) set NoDefaultCurrentDirectoryInExePath=1 for team workers only, but the hook runner,

The author built SecondBrain 2.0 as a large draft PR on top of a Markdown/Git knowledge base, keeping Markdown and Git authoritative while layering services on top. The wiki is the

The owner asked for simpler docs, so the author rewrote README.md and docs/ from scratch rather than editing the old pages. Before: 17 files, 1,756 lines. After the first pass: 7 f

The author finished ticket COD-80 in the codogma-engine repo: a standalone SolidJS + TypeScript/TSX Editor Host under `src/editor/`, replacing the legacy Colibri editor UI while ke

The author had a split-brain problem: the internal canvas agent received a 542-line system prompt, a style guide, a vocabulary and a contact sheet on every turn, but agents reachin

Built a fork of the OpenCode desktop app (DynWork) that connects to systemprompt 0.76 instances. The sign-in screen now runs on real auth: personal access token, one-time code, or

The author is migrating a shipped desktop application and its build toolchain from project-owned JavaScript and Python to Rust, while preserving behavior, low-resource native deskt

The maintainers of OpenWorkGraph (OWG) opened a second roadmap issue after every item in their first roadmap (#264) had a first implementation in `main`. They started from an hones

They wanted every AI-facing feature in their repo to use consistent, reviewable prompts instead of ad-hoc strings scattered across files. Starting from the LangGPT README, they ado

The author packaged a Claude Code skill called home-assistant-manager that turns Claude into a Home Assistant specialist rather than a generic YAML generator. The skill encodes an

The author ran a wiring review of TLS, port binds and loopback in a Rust agent harness (cg-agent-harness) after a prior audit, and found one gap expressed in two places: loopback t

They built little-coder, a coding agent scaffold layered on top of pi (a minimal agent substrate with an agent loop, multi-provider API, TUI, session tree, compaction, and extensio

They had a LangGraph research agent that could search the web, read internal docs, and write summaries to a shared knowledge base. Before shipping it, they wanted guardrails: the a

They set up the ai-website-cloner-template as a standalone project: asked their coding agent to clone the repo into a new folder, strip the origin remote, install dependencies, and

The author removed the built-in smart contacts feature from Core after it was migrated to an official plugin (`cindy-contacts`). Deletions spanned the Harness system prompts (Claud

Working from a task worktree (branch codex/ios-remote-tool-parity) on a baseline commit, the author used Codex to investigate why sessions started from iOS Remote on the same deskt

The author noticed that the `trace_crash` prompt still recommended complete function dossiers even after `build_call_path` had gained retained-parent references (#8435, fixed in #8

The author worked through three bundled changes in the Mikka repo, driven by screenshots of the #715 demo seed and a design review at 1440px light.

Supaterm had drifted 938 commits behind upstream t3code (v0.1.3 through v0.1.5 and nightlies up to 32ecd71726) after an earlier port attempt was reverted. The maintainer requested

The author started from a branch (`mega/absorb-all`) where several absorbed pull requests had left finished work stranded: components existed but no route, menu, or shortcut could

The author integrated the existing Deep Agents runtime into Harness Engine as an opt-in extension, reusing the native runtime behind a DeepAgentsAdapter with typed events before SS

The author released computer-use-bridge 1.0.0, moving the project from a Homebrew-era 0.x layout to an npm package with a single install flow on macOS and Linux. The work covered f

The author added an opt-in agent access layer to Artemis, a Java/Spring + Angular teaching platform, in nine readable commits. First, personal access tokens on the server: created

The author of automcp noticed that most MCP servers are standalone tool projects, which makes it awkward to expose agents and multi-agent workflows over MCP. Their approach: let AI

Robin, Louis, and Thomas kept rebuilding the same agentic patterns across projects, so they separated generic workflow logic from use-case specifics and built Pipelex: a declarativ

A marketing agency inherits a 50-brand client from a previous agency with no playbook. Three brands are overspending, two have stale positioning, and one launches in a regulated ju

When a senior teammate announced a transfer, the team wanted to keep the working knowledge that lived only in her head: how she scoped ambiguous requests, which tradeoffs she flagg

They installed Munder Difflin, the open-source Electron/React agent harness, and pointed it at the terminal coding CLIs they already pay for — OpenAI Codex and Gemini CLI — instead

They had a small CrewAI crew that answered research questions by pulling documents through a LlamaIndex retrieval pipeline and then writing a synthesized brief. The problem was vis

They set up AgentRQ as a shared workspace where human operators and AI agents collaborate on the same task board. Using the Model Context Protocol, agents like Claude and Codex con

They installed Claude Octopus alongside Claude Code and kept the ordinary Claude-native path for routine work, escalating only when they wanted a second opinion. For a risky refact

They had a working Agno research agent (OpenAI model plus DuckDuckGo search tools) and wanted it reachable by other agents without hand-rolling identity and payment plumbing. Inste

They set up CUAWright (formerly Webwright) as a terminal-driven harness so a coding model could launch Playwright browser sessions, inspect pages, and write scripts instead of pred

The team needed to serve large MoE models (DeepSeek-R1 671B, Qwen3, GLM-4.5) in production but did not want to hand-assemble a serving stack from scratch. They picked Chitu (赤兔), a

They took the Vibe-Trading repo and stood up a personal trading agent rather than a one-off script. Starting from the pip-installable `vibe-trading-ai` package (Python 3.11+, FastA

They set up vLLM inference on Huawei Ascend hardware using the vllm-ascend plugin, which extends upstream vLLM with Ascend NPU device support. The work followed the official docume

They wanted a self-hosted, OpenAI-compatible inference endpoint for an internal chat and summarization feature, without sending data to a hosted API. Starting from the LMDeploy REA

They started from the Langfuse repo to get a self-hosted observability backend, then wired their existing LlamaIndex retrieval pipeline into it so every query produced a trace: ret

They installed the Evolver CLI globally from npm and ran it inside an existing git repository, letting the engine treat the repo as the substrate for agent self-evolution. Instead

They wanted an agent that could do the boring first pass of LinkedIn research without copy-pasting between tabs. Using the open-source linkedin-mcp-server, they exposed LinkedIn ac

They wanted a production-grade way to serve PaddlePaddle LLM and VLM checkpoints without rewriting their existing inference clients. Starting from the FastDeploy README, they picke

They installed Atomic Agent, a local-first agent that keeps its control loop and state on the machine, and pointed it at a llama.cpp backend so small quantized models could handle

They used Hermes One (hermes-desktop) as the front end for a self-hosted Hermes Agent instead of hand-managing the CLI. The app ran the official Hermes install script, placed Herme

They installed Attention Span, a small collection of Claude Code output styles, to change how the agent talks rather than how it codes. Each style is a single markdown file dropped

They wanted coding agents running fully locally on a Mac, with no cloud API keys. They installed Rapid-MLX on a stock Apple Silicon machine using the curl install script, restarted

They took an existing agent backend (Codex and OpenCode, with Claude Code and DeepSeek also supported) and wrapped it in LongHorizon-Harness, a loop-engineering layer rather than a

A computational biology group wanted to standardize how their lab turns raw 10x Genomics count matrices into annotated cell-type calls. Instead of hand-writing another bespoke note

They started from a project root and ran `npx impeccable install`, reloaded their coding tool, and ran `/impeccable init` so the agent read the codebase and wrote a PRODUCT.md capt

They installed the Eigent desktop app, which wraps CAMEL multi-agent orchestration in a local cowork interface. Instead of writing agent code, they described a task in natural lang

They wanted their coding agent to stop grepping blindly and re-reading whole files, so they stood up XERJ, a single local Rust binary that indexes a repository's code, docs, specs,

They wanted agents to stop guessing about a mid-sized Python/TypeScript monorepo, so they ran Graphify over the repository to extract a structural graph of modules, imports, and ca

They installed AutoHarness as a Claude Code plugin from the tigerless-labs marketplace, then let it run in the background while doing normal work. Each session that did enough work

The team started from a written brief in OpenDesign's workspace, then handed the build to a coding agent (Cline and Codex) pointed at the project's design system, templates, and sk

They installed the headroom-ai package and used `headroom wrap claude` and `headroom wrap codex` to route existing agent sessions through the local compression proxy on port 8787,

They started from a plain markdown changelog and a rough product brief sitting in the repo. Instead of hand-editing a doc, they pointed html-anything at the repo and let it detect

The author (bojieli) published a full book, 深入理解 AI Agent：设计原理与工程实践, built around the formula Agent = LLM + context + tools. The repo ships the complete manuscript, figures, and 10

They took the llama.cpp WebUI and turned it into a friendlier desktop-style chat app. The fork keeps the llama.cpp server as the model backend but layers on a redesigned interface

They set up LLM X, a browser-based chat client that makes no external API calls, and wired it to local model servers. They installed Ollama and pulled a model, then configured OLLA

They set up Orca as a desktop orchestrator on their repo and used its parallel worktree feature to fan a single refactor prompt across multiple Codex agents. Each agent ran in its

They cloned the AgenticSeek repository and stood up a fully local, voice-enabled agent stack on their own machine. Instead of pointing at a cloud API, they wired the assistant to a

They installed the planning-with-files skill globally via the Agent Skills CLI and let its lifecycle hooks drive a three-file planning loop inside a repo. Instead of relying on a p

Started from a 40-page PDF (a market study) and wanted a 12-slide internal briefing rather than a screenshot-style deck. Installed ppt-master locally, pointed the agent at the PDF,

The developer wanted to stop paying per-token API bills while prototyping an internal chat assistant, so they self-hosted an open-source model instead of calling a hosted provider.

They treated ECC as the harness layer rather than a single tool: cloned the repo, read the README and docs, and installed the npm packages (ecc-universal, ecc-agentshield) plus the

They started from the microsoft/generative-ai-for-beginners curriculum, working through the early lessons on generative AI and LLMs, prompt engineering, and building applications w

This recipe groups chitu, lmdeploy, opencode, vLLM because they appear together in registry README cross-links — a signal that maintainers (or the community) treat them as one stac

They stood up invisible_dots on a machine with hardware virtualization, ran `setup --all` to install QEMU and build the Dot images, and opened the local web UI at 127.0.0.2:3000 wi

They wanted to know whether their agent stack's inference layer was actually the bottleneck, so they built a benchmark harness around TensorRT-LLM instead of trusting single-reques

They took the obsidian-second-brain repo, which ships 8 agents and 48 commands, and pointed several different coding CLIs at the same Obsidian vault so the vault, not the CLI, hold

They wanted to stop hand-modeling repetitive props and instead describe scenes in natural language. Using the mcp-for-blender project (formerly blender-mcp), they ran the one-comma

They wanted local inference that a teammate could run without a Python environment, CUDA toolkit, or model-download dance. Starting from the llamafile README, they downloaded a sma

The maintainers assembled an opinionated, stack-agnostic catalog of 107 Claude Skills that covers the full lifecycle of building, launching, and growing a brand and website: brand

They stood up Ekko Studio as a self-hosted web console (npm global install, then `ekko-studio-web start`) rather than the desktop build, so the backend would live on the same machi

They wired the n8n-MCP server into an MCP-capable AI assistant (Claude or similar) so the model could look up n8n node documentation, properties, and operations instead of guessing

They were running long agentic coding sessions with codex and opencode and kept hitting the same wall: every file read, test run, and log dump landed raw in the context window unti

They wanted an agentic coding loop and a general chat assistant without sending repository code to a hosted API. Starting from the Ollama README, they installed the runtime on thei

The user wanted to add a small but real feature to an existing TypeScript web app: a saved-search feature with a REST endpoint, a UI toggle, and persistence. Instead of prompting t

They started from the OpenAI Agents SDK quickstart, created a Python 3.10+ virtualenv, and installed openai-agents. They defined a triage Agent with instructions that classify an i

They wanted a repeatable way to turn a rough question into a polished written brief without babysitting a chat window. Starting from the AutoGen quickstart, they installed autogen-

They started from the LangChain quickstart, using init_chat_model to bind a chat model behind a standard interface, then moved orchestration into LangGraph so the triage flow becam