New stories

I built Ochat, a toolkit for building AI agent workflows out of a small set of primitives.

The core primitive is ChatMarkdown (ChatMD): a single .md file is both:

the prompt/program (model config, tool allowlist, instructions, context), and the auditable transcript (assistant replies + tool calls + tool outputs) The part that feels most powerful in practice is that this simple building block scales: with good prompting + a curated tool set you can build lots of workflows, and then package them as prompt packs by mounting other prompts as tools (“agent-as-tool”). That lets you assemble Claude Code/Codex-style “agent apps” as just a folder of .md files.

High-leverage built-ins (especially for coding workflows):

apply_patch (repo-safe atomic edits) read_file / read_dir (safe grounding in local files) webpage_to_markdown (web ingestion + GitHub blob fast-path) local retrieval: index_markdown_docs + markdown_search code retrieval: index_ocaml_code + query_vector_db import_image (vision inputs) Extensibility: beyond built-ins, you can add narrowly-scoped shell wrappers, and (optionally) import external tools via MCP. MCP isn’t the point of the project, but it’s useful when you want to reuse existing tool servers.

You can run the same prompt file via:

chat_tui (interactive terminal UI; persistent sessions; branching/export; manual context compaction) ochat chat-completion (scripts/CI) mcp_server (expose prompts as MCP tools) Caveats: provider support today is OpenAI-only; project is research-grade and evolving quickly.

Repo: https://github.com/dakotamurphyucf/ochat Demo: https://youtu.be/eGgmUdZfnxM

If this resonates: stars help a lot, and I’d love early adopters + contributors (prompt packs, examples, docs, tool integrations).

Minimal snippet (prompt pack orchestrator + optional MCP tool):

  <config model="gpt-5.2" reasoning_effort="medium" temperature="0"/>

  <!-- core built-ins -->
  <tool name="read_dir"/>
  <tool name="read_file"/>
  <tool name="apply_patch"/>
  <tool name="webpage_to_markdown"/>

  <!-- optional: import an external tool via MCP -->
  <tool mcp_server="stdio:npx -y brave-search-mcp" name="brave_web_search" />

  <!-- prompt-pack tools (agents as tools) -->
  <tool name="plan"   agent="prompts/pack/plan.md" local/>
  <tool name="code"   agent="prompts/pack/code.md" local/>
  <tool name="review" agent="prompts/pack/review.md" local/>

  <developer>
  You are the orchestrator. Call plan first.
  Keep edits small. Before apply_patch: explain the diff and wait for confirmation.
  </developer>

  <user>
  Add a Quickstart section to README.md.
  </user>

I recently ran an audit on our latest full-stack repo to figure out why "spinning up a new project" felt like such a heavy lift. I counted every file required just to reach a "production-ready" baseline—before writing a single line of unique feature code.

The count was roughly 600 files.

To be clear, I'm not talking about a `create-react-app` sandbox. I mean a compliant, scalable SaaS foundation: Next.js frontend, Node.js/NestJS backend, mobile wrapper, CI/CD pipelines, and enough security config to pass a SOC2 audit.

It sounds ridiculous (and honestly, it feels ridiculous), but when I broke it down, I couldn't find many files I was willing to delete.

Here is where the bloat comes from:

First, the "Configuration Hell" accounts for about 40-50 files alone. We aren't just dealing with `package.json` anymore. It's `tsconfig.json` (base), `tsconfig.build.json`, `tsconfig.spec.json`... multiplied across frontend, backend, and shared libraries. Then add `.eslintrc.js`, `.prettierrc`, `jest.config.js`, `vitest.config.ts`, `nodemon.json`, and the Docker-compose variants for dev, test, and prod.

Then there’s the DevOps and Quality layer. We have roughly 20-30 files for GitHub Actions workflows (lint, test, build, deploy, semantic release), Husky hooks (pre-commit, commit-msg), and pull request templates.

But the real multiplier is the separation of concerns. In a modern monorepo, a "Hello World" isn't just `console.log`. It’s: - A NestJS module (Controller, Service, Module, DTO, Entity, Unit Test, E2E Test). - A Next.js slice (Page, Component, Type definition, API client wrapper). - A shared library entry.

We found that adding a single "minimal" API endpoint usually touches 5-7 files just to maintain architectural standards.

The trade-off is painful. On one hand, this setup handles the things we used to forget: security headers, proper logging, consistent error handling, and type safety across boundaries. It prevents the "spaghetti code" distinct to startups that scale too fast.

On the other hand, the cognitive load of managing a 600-file "empty" project is massive. Updating dependencies becomes a chore because a major version bump in one tool (like ESLint) cascades through forty config files.

I’m curious how others are handling this "starting line" complexity.

Are you accepting the boilerplate as the cost of doing business? Or have you found a way to strip this down without sacrificing the compliance/safety guardrails that enterprise clients demand?

It feels like we've over-engineered the entry point of software development, but I’m not sure what the alternative is for a serious project. We tried going "lean" initially, but spent weeks retrofitting auth and testing harnesses later—which was worse.

Is there a middle ground I'm missing, or is ~600 files just the new normal?

Uber is investing $100 million to build a network of electric vehicle charging stations to support its future robotaxi fleet. The investment aims to create a reliable charging infrastructure to enable widespread adoption of electric vehicles for Uber's autonomous ride-hailing services.

I am feeling nostalgic about games like Dangerous Dave. Haven't found a good hack to do that. Thinking of utilising my over powered macbook to host LLMs offline and use agents to build those games.

Any simple stage games, you can think off for me to start?

The article discusses the potential dangers of 'agent orchestrators,' which are systems that automate the deployment and management of software agents. It argues that these systems can lead to unintended consequences and pose risks to security, privacy, and control over technology.

I had the idea for this site when I wanted to hire a CAD designer to turn a drawing of a simple enclosure into a 3D model. Fiverr wasn’t gonna work for me: fees cut into what I could pay the freelancer, flat rates don't reflect project complexity, and hourly rates are unpredictable when you're a broke college student on a tight budget. I'd rather share a form made to collect offers, then pay whoever offered a good deal directly. So I built offerlog.io.

Offerlog is a free and simple tool to hire, sell, barter, buy, or auction without being restricted by an online marketplace:

- No account necessary - Create and customize your campaign - Share your public URL (on campus, social media, around town, …) - Receive offers via private link

It's 2 parts Google Forms, one part Craigslist, one part eBay :) This is my first launch — any feedback is a huge win. Try it out and let me know what you think, bonus points if you find a bug!

The article discusses the potential risks and concerns associated with AI agents having broad access, including privacy issues, security vulnerabilities, and the need for robust oversight and governance frameworks to ensure responsible development and deployment of AI systems.

The article explores the Claude C compiler, an innovative tool that promises to revolutionize software development by automating the tedious aspects of coding and enabling developers to focus on more complex problem-solving tasks. It highlights the potential of Claude to streamline the software development process and provide insights into the future direction of the industry.

Hey HN, I'm Josiah. We love voice dictation, but wanted an open source version for transparency, privacy, and something that everyone could contribute to. So we built Voquill, an open source alternative to WisprFlow, Monologue, and Willow.

It lets you dictate into any desktop app. Press a hotkey, talk, text gets inserted. You can run Whisper locally, use our server, or wire up any provider you want (OpenAI, Claude, Groq, OpenRouter, whatever). You have full control over where your data goes.

Runs on Windows, macOS, and Linux. Open source, AGPLv3, built with Tauri and Rust. We're working on a mobile app too (Flutter).

To try it: Download from the repo or voquill.com. Click "local setup" on first launch. Hope you like it!

Graham's number is an extremely large number, originally defined by the mathematician Ronald Graham, that has applications in the field of mathematics. It is an upper bound on the solution to a specific problem in Ramsey theory, and is considered one of the largest numbers with a concrete mathematical definition.

The article explores the debate over the fundamental mathematical description of reality, focusing on the long-standing disagreement between physicists who argue for a finite versus an infinite number of dimensions needed to describe the universe.

BrowserClaw is an open-source web browser automation framework that allows developers to write tests and automate web browsing tasks across multiple browsers and platforms. It provides a unified API for interacting with different web browsers and supports features like headless mode, screenshot capture, and parallel test execution.

Portabase is an open-source, cross-platform database management system that provides a user-friendly interface and supports a variety of data types. It is designed to be a simple and customizable solution for managing personal and small-scale databases.

The article discusses the importance of observability and tracing for building effective AI agents, highlighting the need for a robust observability system to monitor and understand agent behavior, and the benefits of tracing to gain insights into the decision-making process of the agent.

The article explores the world of Very Short Rhythm Games (VSRGs), a genre of rhythm games that emphasize extremely fast and challenging gameplay. It delves into the history, characteristics, and evolving community surrounding this niche genre within the broader rhythm game landscape.

This article discusses the author's experience with running Debian and using Rust as a primary programming language on a Unix-based system. It covers the challenges and benefits encountered while working in this setup, providing insights for others considering a similar approach.

The article discusses the rise and fall of empires, using historical examples to explore the cyclical nature of power and the importance of adapting to change. It examines the factors that contribute to the downfall of dominant institutions and the potential for new ideas and paradigms to emerge in their place.

The article announces the release of version 0.1.0 of the mogamp software, which is a tool for managing Mophie device profiles on Windows. The release includes new features and bug fixes, and provides instructions for installing and using the software.

LocalizeFlow is a localization platform that helps companies streamline the translation process for their digital content, enabling efficient management of multilingual projects and ensuring high-quality translations across multiple languages.

The article explores the growing divide between 'original' programmers and those who primarily use AI-powered tools, highlighting the potential identity crisis faced by developers as AI becomes more prevalent in the field. It discusses the implications of this shift and the need for developers to adapt their skills and approach to remain competitive.

GhostInk is an open-source text editor with a focus on privacy and security, offering features like end-to-end encryption, password protection, and offline usage to ensure users' data remains secure and confidential.

I built Unbury because as someone with ADHD, I kept screenshotting things I swore I'd come back to - and ofc never did. That restaurant someone recommended. A book I saw on someone's story. Concert tickets I meant to buy. All buried under 100,000 screenshots I'll never scroll through.

So I built an AI that actually understands why you saved each screenshot and sorts them automatically - Watch, Buy, Read, Listen, Event, Place, Inspo, Memory. The part I'm most proud of: everything runs 100% on your device (edge AI). No cloud. No account. No wifi needed. The AI downloads once during setup, then works completely offline.

Would love to hear how you use your screenshots - or if you're like me, how you forget about them.

The article compares the governance approaches of the United States and Singapore, highlighting Singapore's emphasis on pragmatism and long-term planning over democratic ideals, and the challenges the U.S. faces in balancing different stakeholder interests and values.

Researchers have found that the communication of seal pups is more similar to human communication than previously thought, with seal pups using complex vocalizations and social interactions to convey information and form social bonds.

I’ve been working on a Rust macro called Banish for defining rule-based state machines declaratively.

Instead of manually writing transition loops, Banish evaluates rules within a state until no rule fires (a fixed-point model), then transitions. The macro expands into regular Rust, which allows for seamless integration.

The goal is to make complex rule logic and state machines easier to express while keeping runtime costs identical to handwritten code.

The project was featured as Crate of the Week in the Rust newsletter this week. I'd love to hear your feedback.

Example: use banish::banish;

fn main() { let buffer = ["No".to_string(), "hey".to_string()]; let target = "hey".to_string(); let idx = find_index(&buffer, &target); print!("{:?}", idx) }

fn find_index(buffer: &[String], target: &str) -> Option<usize> { let mut idx = 0; banish! { @search // This must be first to prevent out-of-bounds panic below. not_found ? idx >= buffer.len() { return None; }

            found ? buffer[idx] != target {
                idx += 1;
            } !? { return Some(idx); }
            // Rule triggered so we re-evalutate rules in search.
    }
}

Hey HN. I built this because I've been in therapy for years and noticed that a big part of what therapists do is ask the right questions at the right time. I wanted to see if an AI could serve as a daily self-reflection tool — not replacing therapy, but as a complement to it. Some design decisions and why:

Desktop-only, intentionally. I think therapy should feel like sitting down with your thoughts, not scrolling on your phone. The desktop constraint is a feature. BYOK (Bring Your Own Key). You use your own Claude API key. No backend, no data collection, no accounts. Your conversations never leave your machine. This felt non-negotiable for something dealing with mental health. Built with Claude Code. I work full-time as a team lead at an edtech company, so this was built in evenings and weekends, mostly through vibe coding sessions. I use it myself daily. 15–20 min sessions with Opus + extended thinking. After weeks of use, it picks up on patterns in how you think — recurring avoidance behaviors, cognitive distortions, etc.

The name comes from "Gnothi Seauton" (Know Thyself) — the inscription at the Temple of Delphi. There's no comparable open-source tool in this space. Every mental health AI app I found is closed-source and collects user data. I wanted to build the alternative I wish existed. Feedback welcome — especially on the approach, architecture, or if this is fundamentally a bad idea. Happy to discuss. GitHub: https://github.com/Lepuz-coder/opengnothia

The article explores the process of watching large language models (LLMs) as they generate text, providing insights into their inner workings and decision-making processes. It delves into the importance of understanding how these AI systems function in order to improve their capabilities and ensure responsible development.