I build AI systems and developer tooling around frontier models, agent workflows, emerging protocols, and unconventional ways of combining cloud AI capabilities into useful engineering systems.
Over the past two years, that work has grown from individual experiments into a broad portfolio of CLIs, MCP servers, agent workflows, prompt and evaluation systems, repository tooling, browser automation, and developer infrastructure. I logged 11,000+ GitHub contributions in the last year alone, across both public and private work.
All of this work has been AI-assisted, and the development itself has been driven through cloud-based frontier AI platforms. The distinction is how I use them. Much of the portfolio — including the majority of that contribution volume — predates my use of modern AI-agent coding harnesses. Instead of treating frontier models as a packaged coding product, I used them as a flexible problem-solving and engineering medium: combining prompts, APIs, tools, browser workflows, automation, emerging protocols, and different model capabilities in ways that were often outside the mainstream product path.
A recurring theme has been asking a different question from the market: not just what does this product already let me do?, but what can these capabilities become when they are composed differently? A lot of the work came from exploring those non-conventional paths, bridging capabilities that were not originally designed to work together, and turning the useful results into repeatable developer systems.
- agentic developer workflows, orchestration, and tool-using systems
- MCP servers, plugins, capability layers, and harness integrations
- tooling that connects frontier models, APIs, runtimes, and developer environments
- prompt engineering, evaluation, benchmarking, and DSPy-based systems
- repository intelligence, code-review, planning, and automation tools
- browser automation and agent-facing web workflows
- CLIs, TUIs, dashboards, registries, and other developer productivity tools
- DSPyTeach — a Python CLI for file analysis, prompt-library audits, teaching briefs, refactor workflows, and agent handoffs using DSPy and multiple model backends
- Human Review — visual HTML and Markdown review tooling for editing files, leaving comments, and returning consolidated feedback to an AI agent
- Registry Atlas — a search-first interactive explorer for discovering shadcn/ui community registry items, browsing registry sources, and comparing component coverage
- gh-repo-manager — a Bubble Tea v2 TUI for managing GitHub repositories as a standalone binary or GitHub CLI extension
- RelayForge — a declarative registry and pipeline tool that resolves and validates repository workflows, compiles native agent definitions, and records artifacts and provenance
- lms-llmsTxt — a CLI and MCP toolkit for generating
llms.txt-style repository documentation with DSPy and LM Studio-compatible workflows - single-file-agents — compact agent implementations for exploring practical agent patterns without unnecessary framework overhead
- deep-researcher-ts — TypeScript work around agent-driven research workflows
- mcpdoc — tooling focused on MCP-oriented documentation and developer workflows
| Package | Current release | Description |
|---|---|---|
| dspyteach |  |
Python CLI for DSPy-powered file analysis, prompt-library audits, teaching briefs, refactor workflows, and agent handoffs. |
A large part of my recent work lives in private repositories and active prototypes. That includes:
- AI developer workbenches and control-plane tooling
- prompt infrastructure, evaluation, and benchmarking systems
- agent supervision, memory, and workflow orchestration
- code-review, session-analysis, and repository-intelligence tools
- browser automation and authenticated agent workflows
- plugin, skill, MCP, and capability-management systems
- project dashboards, registries, and internal developer operations tooling
The common thread is practical AI infrastructure: using frontier AI capabilities in ways that expose more of what is possible than the default product experience, then shaping those discoveries into systems that are useful, inspectable, and reusable.
I tend to favor:
- questioning mainstream AI product assumptions and exploring alternative compositions of the underlying capabilities
- using frontier models as an active engineering and problem-solving medium, not just a coding autocomplete layer
- combining existing tools in non-obvious ways before assuming a new platform or abstraction is necessary
- explicit tools, protocols, and observable workflows over opaque automation
- small end-to-end systems that work before adding architectural complexity
- mature SDKs and libraries before custom infrastructure
- testable agent behavior with clear boundaries, verification, and recovery paths
- developer interfaces that reduce friction instead of adding another layer of ceremony
Languages & application work — Python, TypeScript/JavaScript, Go, React
AI & agents — frontier models, DSPy, LangChain/LangGraph, RAG, structured prompting, evaluation, tool use, agent orchestration
AI infrastructure — cloud AI platforms and APIs, OpenAI-compatible APIs, MCP, plugins, skills, model and prompt tooling, runtime integrations
Developer systems — Git/GitHub, Linux/WSL, browser automation, CLI/TUI tooling, APIs, workflow automation
GitHub embed snippet
[](https://tokscale.ai/u/AcidicSoil)
- LM Studio: https://lmstudio.ai/dirty-data
- X: https://x.com/d1rt7d4t4