Coding Agents

A close look at the macro tricks, discriminator fast path, and literal-union decoding that let Swift mirror TypeScript schemas with far less boilerplate.

Forgecode turns agent behavior into YAML, Handlebars partials, and schema checks, so specialists stay narrow, testable, and terminal-native.

A markdown skill file, a few hosting paths, and a security-first playbook show how autonomous agents can be bootstrapped without a traditional install step.

Replicate’s experimental server swaps endpoint sprawl for a two-step workflow: search the docs, write TypeScript, execute it in a local Deno sandbox.

A stateful orchestrator that wraps autonomous coding in quality gates, checkpoints, and stagnation detection.

How a local-first issue tracker built for a Tokyo hackathon reveals the strange, highly structured future of agent-generated codebases.

A compact TypeScript library that turns folds, unfolds, and refolds into stack-safe Effect programs, so the recursion engine disappears and the algebra becomes the point.

A tiny DSL, a result builder, and a careful solution to tuple flattening, type erasure, and clean route outputs.

Remote access is the obvious feature. The real invention is a stop lane that can jump the queue while Claude stays sandboxed, redacted, and stateful.

A compact Modal scaffold for PyTorch that treats checkpoints, preemption, and `torch.compile` edge cases as first-class problems instead of afterthoughts.

A repo of workflows, rules, and version pins that teaches coding assistants where Holochain logic belongs, what must stay pure, and how to avoid the mistakes that usually surface only after a DHT is already live.

An open-source deep-dive into a pair programmer that treats the shell as home, routes work through tools instead of chatter, and gets more reliable when it becomes less conversational.

A deep dive into the agentic core, from context compaction and tool permissions to the transport and telemetry layer that keeps a terminal assistant coherent across long tasks.

An open-source frontend anti-slop framework built around portable `SKILL.md` files, tunable dials, and specialized variants that steer agents away from generic UI.

How a zero-config Python server translates raw market data into the qualitative signals AI agents need to manage risk.

A local-first daemon that turns Claude Code, Gemini CLI, and Copilot into swappable backends, then exposes the whole workflow through a phone-friendly web interface.

A core/plugin architecture, a single span model, and a graceful no-parse fallback make this repo more interesting than its size suggests.

How this repo turns a resume or job description into structured guidance, a day-by-day prep plan, and a polished PDF resume without relying on brittle prompt parsing.

Claude Code Council turns a coding CLI into a deliberation engine. It stages disagreement, hides model identities, and only then writes the verdict.

A zero-dependency skill for Claude Code that stays dormant until the agent needs it, then pulls one quote from a local corpus and gets out of the way.

A Roslyn generator for zero-allocation unions, explicit-layout tricks, safe fallbacks, and an ASCII byte map right in your IDE.

It scans the repo, weighs blockers, and splits work into what Claude can finish versus what only a human can unlock.

A React and Canvas arcade shooter where Gemini generates structured anomalies, the frame loop stays deterministic, and the fallback path is just as important as the AI path.

How a Rust-based gateway uses a V8 isolate to collapse the Model Context Protocol, saving 98% of token costs by forcing agents to write code instead of reading schemas.

How a Cloudflare-backed terminal bridge moves autonomous coding agents off your laptop and into isolated, multi-repo sandboxes.

How a lean TypeScript extension uses event middleware and a local CLI daemon to seamlessly inject live web search into the Pi coding agent without touching an API key.

How a zero-dependency Claude Code extension uses Gemini's million-token context to ruthlessly audit AI-generated code before it reaches the commit history.

A Spring Boot 1v1 coding platform that keeps the stack lean, executes solutions locally, and turns algorithm practice into a duel system with Elo, rooms, and match state.

A deep look at how `sys.settrace`, object sanitization, and LLM reasoning work together to turn line-by-line execution into a teaching tool that can narrate code, visualize data structures, and probe real runtime complexity.

A deep dive into recursive language models, where `SPLIT`, `MAP`, `FILTER`, and `REDUCE` replace free-form loops with inspectable control flow.

A browser-based editor that blends live collaboration, structured AI analysis, and learning-path feedback into one fast feedback loop for students and teams.

A MERN-based hiring app that pairs resumes with job descriptions, then falls back to keyword-driven questions when Gemini is unavailable.

Inside a Spring Boot backend that streams edits, parses structured file mutations, stores code in MinIO, and ships previews through Kubernetes.

A clean Python wrapper turns cube state into Kociemba’s two-phase logic, showing how much value lives in representation, not reinvention.

A deep dive into the ReAct loop, sandbox routing, and live preview plumbing behind a browser-based frontend builder that treats the LLM like a working teammate.

A TypeScript full-stack app that scores resumes, simulates interviews, tracks XP, and forces Gemini into structured JSON so the whole system can stay coherent.

A browser IDE, sandboxed test execution, AI tutoring, and edge deployment patterns combine into a surprisingly mature competitive-programming stack.

A FastAPI backend, AST parsing, and a ReactFlow graph UI combine to show dependencies as a navigable system map, not a pile of files.

An open-source agentic system that reads a job description, rewrites a master profile with governance rules, scores its own output, and exports ATS-safe PDFs without pretending the candidate is someone else.

A WinForms student project hides a surprisingly thoughtful scoring system, including dice flips, first-roll bonuses, and brute-force move suggestions.

A close look at an async BitNet client that squeezes performance out of a global HTTP pool, keeps dependencies minimal, and bakes product identity into the default prompt.

How an open-source BaaS turns schema, SQL, storage, and deployments into something an AI coding agent can actually reason about.

A blank GitHub repository can still tell a story. This one shows how developers turn a personal learning path into a public artifact before the first notebook, script, or syllabus exists.

It splits instructions, relays browser traffic through a bridge, and keeps the agent useful without letting it touch your machine like a root shell.

It does not stop at source files. Tidewave uses a Model Context Protocol bridge and an in-browser agent so assistants can inspect logs, data, and app behavior before they write code.

A blank GitHub shell becomes a doorway into TestAgent, a specialized model pipeline that drafts tests and completes missing assertions.

The real product is not the model. It is the loop around it: prompts, artifacts, sandboxing, and the control layer that makes an AI tool feel usable.

A deep-dive into the open-source review engine that pairs Tree-sitter parsing, repo-wide retrieval, and severity scoring to act less like a chatbot and more like a senior engineer.