qq means "quick question" - it is read-only, perfect for the commands I always forget.
qa means "quick agent" - it is qq's sibling that can run things, but only after showing its plan and getting an approval by the user.
It is built entirely around the Unix philosophy of focused tools, stateless by default - pretty much the opposite of what most coding agent are focusing on.
Personally I've had the best experience using Groq + gpt-oss-20b, as it feels almost instant (up to 1k tokens/s according to Groq) - but any OpenAI-compatible API will do for now.
Curious if the HN crowd finds it useful - and of course, AMA.
What’s new in 2.5: TabPFN-2.5 maintains the core approach of v2 - a pretrained transformer trained on more than hundred million synthetic datasets to perform in-context learning and output a predictive distribution for the test data. It natively supports missing values, cateogrical features, text and numerical features is robust to outliers and uninformative features.
The major improvements:
- 5x scale increase: Now handles 50,000 samples × 2,000 features (up from 10,000 × 500 in v2)
- SOTA performance: TabPFN-2.5 outperforms tuned tree-based methods and matches the performance of a complex ensemble (AutoGluon 1.4), that itself includes TabPFN v2, tuned for 4 hours. Tuning the model improves performance, outperforming AutoGluon 1.4 for regression tasks.
- Rebuilt API: New REST interface along with Python SDK with dedicated fit & predict endpoints, making deployment and integration more developer-friendly
- A distillation engine that converts TabPFN-2.5 into a compact MLP or tree ensemble while preserving accuracy and offer low latency inference.
There are still some limitations. The model is designed for datasets up to 50K samples. It can handle larger datasets but that hasn’t been our focus with TabPFN-2.5. The distillation engine is not yet available through the API but only through licenses (though we do show the performance in the model report).
We’re actively working on removing these limitations and intend to release newer models focused on context reasoning, causal inference, graph networks, larger data and time-series. TabPFN-2.5 is available via API and a package on Hugging Face. Would love for you to try it and give us your feedback!
Model report: https://priorlabs.ai/technical-reports/tabpfn-2-5-model-repo...
Package: https://github.com/PriorLabs/TabPFN
BUT, like many I kept getting stuck and frustrated where I wanted to make changes with the Agent that I knew I could've made without it but I had *no clue* how things worked.
I created Intraview to help me build and maintain a mental model of what I was building (or had vibed) so I could use my knowledge to either fix it myself, or provide more directed instruction. It grew into something that's transformed my workflow in a pleasant way.
Intraview is a VS Code extension that allows you to create: - Dynamic code tours built by your existing Agent - Storage and sharing of tours (it's a file) - Batch Feedback/commenting inline in IDE in-tour and without (it's also a file)
Here's a video walkthrough for the show vs tell crowd where I jump in a random (Plotly JS) open source repo and build a tour to get started: https://www.youtube.com/watch?v=ROBvFlG6vtY
Talking tech design, this is very different than most because the whole App is cloudless. Not server less, there's no external APIs (outside basic usage telemetry).
- basic TypeScript app, JS/CSS/HTML
- Localhost MCP server inside VS Code (one per workspace open)
- re-considering the user experience given there's no database
- trying to build a reasonable experience to manage MCP connection across so many different setups.
- testing the many forks, Agents and themes because I wanted to make it look native (I'll probably reverse course here in future iterations)
- New project/developer onboarding
- PR reviews
- Keeping up with Agentic code
- Perf reviews (for EM), you could build a tour biggest contributions by a GitHub handle
- Planning alignment and review with your Agent
- for VS Code: https://intraview.ai/install?app=vscode
- for Cursor: https://intraview.ai/install?app=cursor
- Create an Intraview the onboarding for this app..
- Let's use Intraview to gather my feedback on [whatever you created]. Break down steps such that I can provide good granular feedback.
And because this is HN. A relevant quotable from PG.
“Your code is your understanding
of the problem you’re exploring.
So it’s only when you have your code
in your head that you really understand
the problem.”
— Paul GrahamIto is a voice to intent app that turns what you say into structured text: notes, messages, code, or any text field you’re working in. It’s designed to feel fast, clean, and distraction free. It works on Windows and Mac.
Most speech tools are either locked inside closed systems or overly complicated & overly parameterized and difficult to setup. We wanted something that works like a native app, looks good, and stays transparent about your data. Ito is open-source under GPL-3.
Our focus is simplicity and polish. You can use a few different models and providers but we're still working on an entirely local first experience. It's also pretty easy to host yourself if you want to avoid our infra all together.
We’re still early, but it’s already stable enough that I use it daily for coding notes, writing, and quick thoughts between tasks.
Try it here: https://ito.ai
Code: https://github.com/heyito/ito
Would love feedback, critiques, and ideas for integrations.
One of the most empowering applications of LLMs is enabling non-technical people to build apps and products. This value is reflected in the revenues of companies like Lovable and Bolt. Many of Giga's paying customers are business executives building valuable automations and internal tools that increase efficiency.
But, the incumbents currently operate on pay-as-you-go pricing, which is a predatory business model that I ethically disagree with. I believe the future of vibe coding tool pricing needs to be outcome based vs PAYG. The latter often feels like being held "hostage" over time, when there's vendor lock-in, and especially when the marketing promises are not met.
One step towards that is providing free or low cost inference. The user can continue building till they reach the desired outcome for a longer duration, which is possible if we can somehow make the inference cost negligible. And, the most proven model for offering free stuff online has been ads.
That's why, I've combined the two. I'm offering completely free Claude Sonnet 4.5 for use in Claude Code to empower a new segment to start building with AI.
Launch video (420k+ views): https://twiiit.com/NamanyayG/status/1982939951571591438
How it works:
- We are backed by sponsors. - We inject ads in the responses (a mix of contextual and static). E.g., if you ask about the best AI agentic memory tools, we'll recommend our sponsor https://supermemory.com/ - We store conversations for training or sharing with partners (transparently we are not data sharing right now, but retain the right to do so in the future). - We rate limit dynamically to allow fair usage for all our users. - We are offering the best Claude models for now. Depending on sponsorship, we might have to transition to free or OSS models down the line (e.g. grok-fast-1 or gpt-oss). - Our business actually makes revenue from our premium tool, https://gigamind.dev/context, which creates AI rules file for your project like AGENTS.md automatically.
How to try:
- Register on https://free.gigamind.dev/ - We provide you with an API key and a Claude Code compatible proxy URL. - With a few lines of environment variable changes, you get to use Claude Code, for free. - We'll run out of money if we serve everyone from HN today, so only the first 2⁶ people with coupon code `1337HN` get auto-accepted immediately.
Excited to hear your thoughts!
It's quite a leap since our first prototype last year -- we bring agent mode to interact with data, together with an online demo that you can play with (https://data-formulator.ai/).
"Vibe with your data, in control" -- featuring agent mode + interactive control to play with data, it should be more fun than last time you discovered it!
- Load whatever data - structured data, database connections, or extract from screenshots/messy text - Flexible AI exploration - full agent mode OR hybrid UI+NL control for precision - Data threads - branch, backtrack, and manage multiple exploration paths - Interpretable results - inspect charts, formulas, explanations, and generated code - Report generation - AI creates shareable insights grounded in your data
* Online demo at: https://data-formulator.ai/ * Github: https://github.com/microsoft/data-formulator * new video: https://www.youtube.com/watch?v=GfTE2FLyMrs * take a look at our product hunt page: https://www.producthunt.com/products/data-formulator
The Anthropic post (https://www.anthropic.com/engineering/code-execution-mcp) showed how agents can avoid token bloat by writing code to call MCP tools instead of using direct tool calls.
Their approach generates TypeScript files for each tool to enable progressive discovery. It works well but introduces complexity: you need to generate files for every tool, manage complex type schemas, rebuild when tools update, and handle version conflicts. At scale, 1000 MCP tools means maintaining 1000 generated files.
I built codex-mcp using pure dynamic execution. Instead of generating files, we expose just two lightweight tools: list_mcp_tools() returns available tool names, and get_mcp_tool_details(name) loads definitions on demand. The agent explores tools as if navigating a filesystem, but nothing actually exists on disk.
Code snippets are stored in-memory as strings in the chat session data. When you execute a snippet, we inject a callMCPTool function directly into the execution environment using AsyncFunction constructor. No imports, no filesystem dependencies, just runtime injection. The function calls mcpManager.tools directly, so you're always hitting the live MCP connection.
This means tools are perpetually in sync. When a tool's schema changes on the server, you're already calling the updated version. No regeneration, no build step, no version mismatches. The agent gets all the same benefits of the filesystem approach (progressive discovery, context efficiency, complex control flow, privacy preservation) without any of the maintenance overhead.
One caveat: the MCP protocol doesn't enforce output schemas, so chaining tool calls requires defensive parsing since the model can't predict output structure. This affects all MCP implementations though, not specific to our approach.
The dynamic execution is made possible by Vercel AI SDK's MCP support, which provides the runtime infrastructure to call MCP tools directly from code.
Project: https://github.com/pranftw/aiter-app
Would love feedback from folks working with MCP at scale. Has anyone else explored similar patterns?
None of the parsers I saw around support proper entity expansion or check the internal DTD for syntax errors. This approximation is not benign, if the XML data processed is passed to other software it could be interpreted differently.
And that's the story of why I made my own.
Though not definitive, I also ran some benchmarks against other libraries:
So I built BookPace — an iOS app that tracks your reading time and helps you build a consistent reading habit.
You can start and stop a reading session manually, or if you read physical books, you can attach an NFC tag to your book and just tap it with your iPhone to toggle the timer automatically. If it’s a library book, there’s often already an embedded NFC tag inside the cover — BookPace can use that too, so you don’t even need to add your own tag.
Features: – Reading timer with streaks, ranks, and badges – NFC tag pairing for physical or library books - Reading stats and heatmaps by day, week, month, year, or lifetime – Focus mode: temporarily block selected apps while the reading timer is running – Cloud sync across devices
I built it entirely in SwiftUI, integrating Apple’s NFC, CloudKit, and Screen Time APIs. It’s been fun bridging the gap between physical reading and digital tracking.
Website: https://bookpace.app
App Store: https://apps.apple.com/app/bookpace/id6753701690
I’d love your feedback — on both the app idea and the implementation. How would you improve it, or what would make it more useful for serious readers?
The Rules:
The goal is to claim the most space
Secondary goal is to kill as many other Ourboroses as you can The how:
To claim space you need to either eat your own tail or reach tiles you've already claimed, tiles that are enclosed when you do so become yours!
To kill other snakes you hit their tails To watch out:
Other players can kill you by hitting your exposed tail
Other players can take your tiles.
I invest across Turkish stocks, US stocks, crypto, gold and mutual funds. Most existing apps felt either too complicated or didn't show daily performance in a clean way. So I created my own.
Key features: - Track stocks, crypto, commodities, FX, and funds in one place - Daily and total P/L, with quick category-level summaries - Clean UI focused on “check your positions in 5 seconds” - Optional account sync (Firebase) or full offline use - Data caching to reduce API calls
Tech stack: - Flutter (mobile) - Node.js + Express backend - Firebase Authentication + Firestore (optional sync) - Local caching layer for API efficiency
Screenshots: (link) App Store / Play Store: (link) GitHub (optional): (link)
I’d really appreciate feedback on: - UI clarity and layout - Which metrics matter most in daily use - Whether a “premium” tier for advanced analytics makes sense
Thanks for taking a look!
I launched this as a SaaS earlier this year, failed to gain traction. Realized I was solving MY problem but not explaining it clearly.
So I'm open sourcing it with a better pitch:
The problem: I had 20+ Tampermonkey scripts for one-off tweaks. Maintaining them sucked. Writing new ones for simple stuff felt like overkill.
The solution: Chat interface where you describe the change, AI generates CSS/JS, applies it instantly.
Daily use cases: - "Dark mode this page" - "Hide YouTube shorts" - "Remove paywalls" (yes, controversial) - "Add keyboard shortcuts"
Technical stuff: - Your API key (Claude/GPT/Gemini/Grok/OpenRouter) - Smart DOM selector with stability scoring (checks for stable IDs, attributes like data-testid, role, aria-label before falling back to classes or nth-child) - Handles Shadow DOM, SPAs, dynamic content - Cloud sync via Supabase (optional)
GitHub: https://github.com/kchander/magix-extension Chrome Store: https://chromewebstore.google.com/detail/magix/ebfhenlkpdngc...
The hard part wasn't the AI - it was making modifications survive page updates. Uses Chrome's UserScripts API (Chrome 138+) to register scripts persistently, handles dynamic content injection, and manages script lifecycle across navigations. Lots of MutationObserver shenanigans for elements that get swapped out by SPAs.
See ya! Also my first open source project :)
It works relatively well for me given what it is, and for now it relieves some of the pain. I plan to eventually rewrite it from scratch without AI assistance as an exercise in learning Rust, so please don't critique the code, I'm aware that it's a mess. I'm just looking to get some feedback - what works well, what doesn't, what's obviously missing in terms of features, etc.
You can chat with PDF documents using models like Phi-3, Llama 3, or Mistral 7B - all running locally with zero backend. Documents never leave your device.
Tech stack: - WebLLM + WeInfer (optimized fork with ~3.76x speedup) - Transformers.js for embeddings (all-MiniLM-L6-v2) - IndexedDB as vector store - PDF.js for parsing
The main challenges were: 1. Getting esbuild to bundle without choking on onnxruntime-node 2. Managing COOP/COEP headers for SharedArrayBuffer 3. Keeping the bundle reasonable (Angular + models = ~11MB base)
Performance is surprisingly decent on modern hardware: - Phi-3 Mini: 3-6 tokens/sec (WebLLM) → 12-20 tokens/sec (WeInfer) - Llama 3.2 1B: 8-12 tokens/sec
Demo: https://webpizza-ai-poc.vercel.app/ Code: https://github.com/stramanu/webpizza-ai-poc
This is experimental - I'm sure there are better ways to do this. Would appreciate feedback, especially on: - Bundle optimization strategies - Better vector search algorithms for IndexedDB - Memory management for large documents
Happy to answer questions!