2025年9月16日 的 Show HN

Hey HN,

I’m Henry, cofounder and CTO at Span (https://span.app/). Today we’re launching AI Code Detector, an AI code detection tool you can try in your browser.

The explosion of AI generated code has created some weird problems for engineering orgs. Tools like Cursor and Copilot are used by virtually every org on the planet – but each codegen tool has its own idiosyncratic way of reporting usage. Some don’t report usage at all.

Our view is that token spend will start competing with payroll spend as AI becomes more deeply ingrained in how we build software, so understanding how to drive proficiency, improve ROI, and allocate resources relating to AI tools will become at least as important as parallel processes on the talent side.

Getting true visibility into AI-generated code is incredibly difficult. And yet it’s the number one thing customers ask us for.

So we built a new approach from the ground up.

Our AI Code Detector is powered by span-detect-1, a state-of-the-art model trained on millions of AI- and human-written code samples. It detects AI-generated code with 95% accuracy, and ties it to specific lines shipped into production. Within the Span platform, it’ll give teams a clear view into AI’s real impact on velocity, quality, and ROI.

It does have some limitations. Most notably, it only works for TypeScript and Python code. We are adding support for more languages: Java, Ruby, and C# are next. Its accuracy is around 95% today, and we’re working on improving that, too.

If you’d like to take it for a spin, you can run a code snippet here (https://code-detector.ai/) and get results in about five seconds. We also have a more narrative-driven microsite (https://www.span.app/detector) that my marketing team says I have to share.

Would love your thoughts, both on the tool itself and your own experiences. I’ll be hanging out in the comments to answer questions, too.

Hi HN!I built *pyproc* to let Go services call Python like a local function — *no CGO and no separate microservice*. It runs a pool of Python worker processes and talks over *Unix Domain Sockets* on the same host/pod, so you get low overhead, process isolation, and parallelism beyond the GIL.

*Why this exists*

* Keep your Go service, reuse Python/NumPy/pandas/PyTorch/scikit-learn. * Avoid network hops, service discovery, and ops burden of a separate Python service.

*Quick try (\~5 minutes)*

Go (app):

``` go get github.com/YuminosukeSato/pyproc@latest ```

Python (worker):

``` pip install pyproc-worker ```

Minimal worker (Python):

``` from pyproc_worker import expose, run_worker @expose def predict(req): return {"result": req["value"] * 2} if __name__ == "__main__": run_worker() ```

Call from Go:

``` import ( "context" "fmt" "github.com/YuminosukeSato/pyproc/pkg/pyproc" ) func main() { pool, _ := pyproc.NewPool(pyproc.PoolOptions{ Config: pyproc.PoolConfig{Workers: 4, MaxInFlight: 10}, WorkerConfig: pyproc.WorkerConfig{SocketPath: "/tmp/pyproc.sock", PythonExec: "python3", WorkerScript: "worker.py"}, }, nil) _ = pool.Start(context.Background()) defer pool.Shutdown(context.Background()) var out map[string]any _ = pool.Call(context.Background(), "predict", map[string]any{"value": 42}, &out) fmt.Println(out["result"]) // 84 } ```

*Scope / limits*

* Same-host/pod only (UDS). Linux/macOS supported; Windows named pipes not yet. * Best for request/response payloads ≲ \~100 KB JSON; GPU orchestration and cross-host serving are out of scope.

*Benchmarks (indicative)*

* Local M1, simple JSON: \~*45µs p50* and *\~200k req/s* with 8 workers. Your numbers will vary.

*What’s included*

* Pure Go client (no CGO), Python worker lib, pool, health checks, graceful restarts, and examples.

*Docs & code*

* README, design/ops/security docs, pkg.go.dev: [https://github.com/YuminosukeSato/pyproc](https://github.com/YuminosukeSato/pyproc)

*License*

* Apache-2.0. Current release: v0.2.x.

*Feedback welcome*

* API ergonomics, failure modes under load, and priorities for codecs/transports (e.g., Arrow IPC, gRPC-over-UDS).

---

Source for details: project README and docs. ([github.com][1])

[1]: https://github.com/YuminosukeSato/pyproc "GitHub - YuminosukeSato/pyproc: Call Python from Go without CGO or microservices - Unix domain socket based IPC for ML inference and data processin"

Hi HN,

I’ve been working on something I’d love to share: 47jobs (https://47jobs.com ) – a marketplace where you can hire AI agents to do tasks instead of human freelancers.

Why? I kept noticing that many tasks on Upwork/Fiverr—coding, content generation, data analysis, automation—can now be handled by AI in minutes, not hours. But there wasn’t a platform built around hiring AI directly.

So I built 47jobs:

100% AI agents doing the work (no humans in the loop).

Jobs get delivered 10x faster, at transparent prices.

You can “hire” an agent for coding, automation, research, etc.

I’d love your thoughts:

Does a pure AI-agent marketplace make sense?

What types of jobs would you want AI agents to handle first?

Any UX or trust issues you’d expect with this model?

This is an early version, and I’m here to learn from your feedback. Thanks!

Hey everyone, I’m Hunter, the founder of Archil. Archil is transforming object storage, like Amazon S3, into infinite, local file systems that provide instant access to massive data sets.

Last year, we launched Archil’s NFS-based product publicly on Hacker News (https://news.ycombinator.com/item?id=42174204), and we were absolutely thrilled to see the response of this community.

Since our last launch, we took a 10 month company-wide bet to build our own, custom storage protocol to deliver true, local-like performance to cloud instances – by behaving closer to a block storage product. Today, we are excited to announce the public availability of this high-performance protocol. You can try it for free today with a single click at https://disk.new (docs at https://docs.archil.com).

After spending 10 years in the storage industry building products like Amazon’s Elastic File System and buying AWS storage on Netflix’s core storage team, I knew that developers faced tremendous problems using storage. Getting easy-to-use persistent storage on a Kubernetes cluster is non-trivial, determining how much storage an application needs can be impossible if it’s bursty, and companies are tired of overpaying for either very expensive storage (like EFS) or unused capacity (like with EBS).

From my time on EFS, I also knew that NFS was not the solution. Users were disappointed to see a 10x performance drop when they moved data from EBS to EFS to share it across multiple instances.

This is why we built Archil.

Archil is a pay-as-you-go disk that automatically grows with your application. Because it synchronizes your data bidirectionally to sources like your Amazon S3 buckets (and other S3-compatible locations), you can connect it instantly to existing data sets and use your file data directly from S3 itself.

When you mount an Archil disk, your instance connects to our managed caching fleet of instances with NVMe devices that provide read-through and write-back caching to your disk’s data sources, like S3. Because we designed a distributed, replicated, highly-durable cache, it’s a safe place for data to be stored before being written back to S3. We only charge users for data that’s actively in the cache, and when you aren’t using your disk, you don’t pay Archil anything.

We’re really excited about the early companies that we’re working with who are building cutting edge CI/CD workers, performing satellite image processing, building serverless Jupyter Notebooks, creating AI-native code sandboxes (have you ever tried to run git directly on an NFS share?), building best-in-class AI agents that use file systems instead of MCP tools, and helping to deliver core AI infrastructure like gateways and compute.

I’m excited to give you all access today, with no charges in the month of September, and I’d love any feedback on the product that you may have. If you’re interested in working on deep, technical problems in the core infrastructure space, we’re also hiring in San Francisco and would love to hear from you (see https://www.ycombinator.com/companies/archil/jobs/svfkDVv-fo...).

Hey HN! This is a fun/educational project I built to learn OS programming. I started working on it right after graduating high school last year and have been working on it on and off during my first year of university. It features a TCP/IP stack, an HTTP server, a RAM file system, a BIOS bootloader, paging and memory management, and concurrent tasks based on cooperative scheduling, along with a custom library. It's written in a C programming style focused on safety (based on a custom library of core abstractions) that's inspired by the writing of Chris Wellons (nullprogram.com).

There is a link to a test deployment in the README. The TCP/IP implementation is nowhere near perfect, of course, so there may be issues loading the page. I'm curious how the system holds up if this post gets any attention ;-)

I'm Vivek, co-founder/CEO of HackerRank (YC S11); You may know us as a hiring tool for developers/companies.

Over the years, we have built up deep expertise in generating programming challenges, and we are now using that to make coding models better.

Our first launch is Model Kombat -- an arena where you can directly compare anonymized coding models, side by side, on real problems.

* Pick an arena (Java, Python, etc.) * Each battle has 3 rounds: see the problem + two model outputs -> vote on which you’d actually prefer * Leaderboards + problem statements are updated weekly.

We already have 400+ challenges live, and our goal is to evolve toward real-world, multi-file challenges and robust tooling for coding model evaluation.

Try it now at: modelkombat.com

We’d love your feedback.

Hey HN! I've created a terminal interface to browse HN using only the keyboard.

All key bindings and theme colors are customizable :)

It was built with React, OpenTUI, bun and HN API, had a lot of fun building this, excited to hear your feedback!

Hey HN!

I built Ghostpipe because:

1. I like to keep data about my software in the codebase and under version control.

2. I don’t like always working in raw text files with domain specific languages (eg Terraform, Openapi, er diagrams).

Ghostpipe is an open source tool that creates a bridge between files in your codebase and applications using webrtc. This lets developers work with user interfaces where appropriate, while still having access to the underlying raw text files.

A few side-benefits to this setup are:

1. AI agents are good at working with local text files, so we can keep using those.

2. Generally speaking, no signup or installation is needed to use Ghostpipe apps, because all relevant data is in the codebase.

I built a few demo apps with Ghostpipe support (Excalidraw & Swagger UI), and I hope this proof of concept spurs some interest in taking this idea further.

Thanks!

I’ve been impressed with Claude Code but one thing that sometimes gets in the way in my workflows is the messy, mangled text that is shown when pasting text from the Claude Code terminal sessions. So I built an open-source utility that cleans extraneous white space, pipes, and other characters from your CC/Codex pastes.

For example, you can turn this:

`How can I create a Claude Code script that │ │ cleans up extraneous characters and cleans up │ │ extra spaces, new lines, and other messiness │

when I copy from Claude Code terminal │ │ prompts or copy code from Claude Responses in │ │ the Claude Code Terminal? It can make it │ │ hard to read, save, and reuse. `

Into this:

`How can I create a Claude Code script that cleans up extraneous characters and cleans up extra spaces, new lines, and other messiness when I copy from Claude Code terminal prompts or copy code from Claude Responses in the Claude Code Terminal? It can make it hard to read, save, and reuse. While this was built with Claude Code in mind it also works on Codex.`

Try it here: cleanclode.com

It’s 100% private (no data collection, tracking, completely open-source). If there’s anything you don’t like please just create a GitHub issue, contribute your change (https://github.com/TheJoWo/Clean-Clode), or comment here. Thanks and hope it’s helpful to some of you

This is Prompt Canvas - a simple, open-source web app that lets you visually build LLM prompt templates as YAML schemas and then generate complete prompts by populating values in the templates. It’s based on a single HTML file with no real privacy concerns and everything is portable thanks to YAML exports.

Check out the example in the dropdown and read the guide to see how it works: https://promptcanvas.ml4den.com/

LLMs like structure and I found that generating prompts like this is an easy way of giving it to them. It can be useful if you’re doing a degree of prompt engineering and you want to test small variations in your prompts; or if you have a use case where you submit the same promps many times but with some input variations. I found that browsing to a YAML file and tweaking one parameter for a particular job is much cleaner than a web of Notion pages which is what I had before.

Some thought and iteration has gone into the templating engine but everything is still early stage! Some of it is opinionated, and some of it is meant to be quite extensible to different use cases. Let me know if it makes sense.

I built this mostly with Gemini 2.5 Pro out of my own necessity. Would love to know if it's useful for you! Feedback welcome; as are bugs and things on GitHub: https://github.com/ml4den/PromptCanvas

I wanted to be able to get at Apple's content distribution network directly instead of guessing when stuff would be made available to me, and found it convenient to have a physical installer handy so I made this

Hey HN! I'm Salim, a content marketer, and I’m working on a website called [quizquestions.org](http://quizquestions.org/). It's my project for building the biggest library of quiz questions.

This is not a quiz website per se, but a library for people who make quizzes.

You see, I make quizzes occasionally. There are many quiz makers, but not many resources for quizzes. And most of the resources are just blogs. So I've wanted to create a more structured website just for this.

Here’s what the site offers at the moment:

- A quiz card: Instead of browsing them, you can get quiz questions in a quiz format - Quiz categories: https://www.quizquestions.org/category - AI question generator: https://www.quizquestions.org/question-generator - A blog page for guides: https://www.quizquestions.org/guides - Saving questions: To use them later for creating a quiz - Sending questions: To send your own questions - Statistics about categories: https://www.quizquestions.org/statistics

This is my first website, so any feedback is welcome!

I built a tiny, typed wire for AI agents to exchange small graphs + telemetry instead of paragraphs.

Ships: • Frozen v0.1 schema (backwards-compatible) • 5-number “shape” digest + holonomy gap (Δ_hol) • Guards to stop self-licking loops / silent deletions / order-debt spikes • Receipts: machine-verifiable JSON (schema-checked in CI)

Repo: https://github.com/terryncew/openline-core Live hub: https://terryncew.github.io/openline-hub/

What feedback helps most: • Field naming in the wire • Guard thresholds • Which adapter you’d want first (WebSocket, store)

MIT licensed.

Hi HN,

We’ve been building InfiniteTalk, an AI-powered tool that transforms images + audio into long-form, lip-synced videos. With just a single image and one or more audio tracks, you can generate talking, singing, or even multi-character conversational videos.

Key features:

Image + Audio Driven Lip-Sync: Upload a static photo and audio, and get a naturally synced talking or singing video.

Multi-Character Conversations (InfiniteTalk Multi): Sync multiple audio inputs to different characters for realistic dialogues.

Long-Form Video Support: Generate videos up to 10 minutes per render—great for podcasts, lectures, or performances.

Singing & Performances: Animate characters to sing songs, rap, or perform scripted content.

Fast & High-Quality: Deliver expressive videos in minutes, ready for marketing, education, entertainment, or social media.

Why we built this: Making engaging video content usually requires cameras, actors, editing, and lots of time. InfiniteTalk removes all of that—allowing creators, educators, and businesses to produce long-form, lip-synced conversational videos from just images and audio. We’d love your feedback on:

Where long-form lip-sync video could be most useful.

Features you’d want in multi-character conversation mode.

API or plugin integrations that could make this more developer-friendly.

Thanks for reading, and excited to hear your thoughts!

Hey everyone

We’ve just released v0.2.0 of should: a lightweight assertion library for Go with zero dependencies and expressive error messages.

This release brings several new assertions (e.g., BeError, BeWithin, BeSameTime), refactors for better type handling, and improved docs. We’ve also added support for formatted messages and streamlined some core functions based on user feedback.

Repo: https://github.com/Kairum-Labs/should

Feedback and suggestions are very welcome!

Hey, I'm Vlad, founder of Spyc (pronounced "spice"). I've been building this as a side project turned fulltime over the past few months, drawing from my own frustrations as a DIY investor juggling spreadsheets and apps that either lacked privacy or were bloated with features I didn't need. I'm actively working on it, iteratively adding and exploring new features to enhance the dashboard from a large list of ideas.

Spyc is a web app that lets you track your net worth and portfolio securely without storing any personal identifiable info. You upload your statements (PDFs or CSVs from brokers), it parses them ephemerally - processing in realtime and discarding the originals right after - and gives you visuals like allocation pies, performance lines, and heatmaps. It also runs simple simulations (e.g., Monte Carlo for projections). Everything's anonymized and stored under a hashed key from your Google signin, with a one-click delete option.

What sets it apart: No automatic integrations or data hoarding like many trackers. It's manual-upload only to keep control in your hands, focusing on privacy as the core. It's optimized for mobile too.

To try it out: Head to spyc.io - you can sign in with Google (no email/password setup) and start uploading sample data immediately. I've set up a demo mode with pre-loaded anonymized datasets if you want to poke around without your own files (just click "see sample statements" on the dashboard).

This is the first public share; no prior HN threads. Looking forward to your thoughts, bugs, or feature ideas - I'm here to discuss.