Coding Agents

An open-source AI co-teacher that learns your voice, works locally, and uses a temporal knowledge graph to turn curriculum history into better lesson planning.

How a Rust daemon uses tmux panes, git worktrees, and Maildir to orchestrate a hierarchical company of AI coding agents completely in the terminal.

A curated data repo that tracks coding models, agents, IDEs, and app builders, then exposes the whole landscape through CSVs, Hugging Face, and MCP.

A Bun-powered, Docker-isolated assistant platform that runs across Discord, Telegram, and the web while proxying sensitive credentials outside the model's view.

Aaron Francis turns web research into a straight-line pipeline: fan out search, canonicalize and dedupe URLs, fetch with retries, then synthesize a citation-grounded brief.

While standard AI tools burn tokens reading entire codebases, this native terminal UI uses AST parsing and local sandboxing to give LLMs exactly what they need.

ArenixDev/forge turns instructions into a governed hierarchy, strips ambiguity out of prompts, and makes AI prove it can follow the contract before code is trusted.

How a strictly orchestrated collection of Markdown files turns generic LLMs into economically-aware Web3 security auditors.

A tiny Claude Code skill that reads Lark Minutes, detects action cues, and pushes tasks into the Lark ecosystem with a human confirmation step.

A TypeScript CLI and Claude Code plugin that uses browser-auth plus reverse-engineered RPC calls to let AI agents create NotebookLM artifacts, run deep research, and manage sources without a public API.

A tour of Sharaku Satoh’s FLIP theory, where pseudo-personas, layered commands, and thinking methods turn system prompts into engineered behavior.

Not a chatbot layer, but a stateful admin system with queues, abilities, background slices, and a safety model built for autonomous site tasks.

A tiny skill file, an MCP bridge, and live schema checks turn AI agents into self-updating Replicate users.

Moving beyond vibe coding with an automated Prime-Implement-Validate loop that deletes code if it lacks a failing test.

How a recursive Python orchestrator turns informal reasoning, Lean 4 verification, and `sorry` placeholders into a divide-and-conquer system for formal mathematics.

A deep dive into a repo that packages prompts, tests trigger rates, and turns AI behavior into something you can version, distribute, and improve.

A TypeScript repo that turns Claude into a file-editing agent with three tools, one tight orchestration pattern, and a surprisingly fragile idea at its center: surgical string replacement.

A terminal-native AI research desk for JPX data, valuation models, and a separate evaluator loop that helps keep finance answers grounded.

Li Jigang's `ljg-skills` treats analysis, rewriting, and visual synthesis as modular skills, then pushes them into a bento-card output.

ABRAXAS turns JSON prompts, shell output, and a self-copying loop into a closed system that feels less like an app and more like an experiment in autonomy.

Behind a minimalist zero-build landing page lies an ecosystem designed to force chaotic AI coding agents into strict, markdown-driven engineering workflows.

A tiny Python kernel, a versioned skill registry, and a subprocess executor turn a model into a system that can extend itself in real time.

Aiden Bai turns SolidJS's sharpest footguns into AGENTS.md guardrails, revealing a new kind of infrastructure: documentation written for code-generating agents, not humans.

Instead of summarizing a topic, it hunts for the irreducible generators, tests them against counterfactuals, and exposes the structure hiding under the noise.

A tiny TypeScript extension turns OpenClaw into a constrained trading agent with local key custody, Jupiter-powered swaps, and a built-in momentum score that encodes a very specific kind of crypto judgment.

`ljg-skill-fetch` is less a scraper than a decision tree. It turns Claude Code into a local, fallback-driven pipeline that can pull URLs and documents into clean Markdown.

How a TypeScript daemon turns everyday messaging apps into a mobile-first control plane for autonomous coding agents.

A grumpy terminal companion for the Pi coding agent, built to score risky changes, roast over-engineering, and keep AI code minimal enough to survive contact with reality.

How a minimalist Go daemon wraps Anthropic's terminal tool to build a self-modifying AI assistant without a single API call.

A deep dive into the wrapper that replaces open-ended prompting with staged intent, source checks, and feedback loops that make AI code feel less like improvisation and more like engineering.

A Go-based deep-research tool with a real budget ledger, verbatim quote enforcement, and a local-data boundary that keeps raw rows off the prompt.

A document-first workflow that moves agent state out of chat, into locked Markdown, and through a strict audit loop that humans can actually inspect.

How an early devnet learning journal perfectly captures the shift from Solidity's ledger-based tracking to Move's resource-oriented architecture.

A deep dive into the project that makes Claude act like a product manager, build manager, QA lead, and release engineer for React Native apps.

A lean map-reduce implementation for free-threaded CPython, built around chunking, low-lock coordination, and a new assumption: threads can finally do real work on CPU-heavy tasks.

A tiny Bash toolkit shows how Claude Code’s hook layer can override rigid permissions, repair dontAsk mode, and make safety decisions from live context.

Raul Riera's open-source client treats context as a living session, not a stack of tabs.

A deep dive into the AGENTS.md tool that teaches copilots how to build Appwrite apps the way Appwrite wants them built.

A Claude Code plugin that edits, measures, reverts, and remembers. It uses Git, JSONL, and confidence scoring to turn optimization into a closed-loop research system.

A Python framework where one agent proposes, another attacks, and the sandbox decides which code survives.

How a lightweight simulator replaces rigid academic DSLs with the elegance of functional head movement and "Dictionary-as-Code" architecture.

How a local-first Go runtime bridges the sensory gap between human UI feedback and agentic code modification.

A migration toolkit for Python teams moving from Azure OpenAI chat completions to the Responses API, with scanners, compatibility checks, agent instructions, and rollout tooling.

A single SKILL.md file turns "save this" into a structured workflow, fetching web content, cleaning it, tagging it, and filing it into Org-mode with almost no friction.

A Claude Code Skill that breaks intent into Anchor, Vector, and Matrix, then renders the result as a visual report instead of a blob of advice.

A shell-native review loop where one model writes, another challenges, and the system refuses to trust either one blindly.

How one repository turns genomic data, single-cell analysis, neoantigen ranking, and structural validation into a patient-owned decision engine for layered cancer treatment.

A prompt-first quickstart for building a chat-native onchain operator that reads docs, installs skills, and acts with guardrails.