neomantra

I maintain an OSS SDK for Databento market data. A year ago, I naively wrapped the API and certainly felt this pain. Having an API call drop a firehose of structured data into the context window was not very helpful. The tool there was get_range and the data was lost to the context.

Recently I updated the MCP server [1] to download the Databento market data into Parquet files onto the local filesystem and track those with DuckDB. So the MCP tool calls are fetch_range to fill the cache along with list_cache and query_cache to run SQL queries on it.

I haven't promoted it at all, but it would probably pair well with a platform like this. I'd be interested in how people might use this and I'm trying to understand how this approach might generally work with LLMs and DuckLake.

[1] https://github.com/NimbleMarkets/dbn-go/blob/main/cmd/dbn-go...

That sort of GPU code has a lot of concepts and machinery, it’s not just a syntax to express, and everything has to be just right or you will get a blank screen. I also use them differently than most examples; I use it for data viz (turning data into meshes) and most samples are about level of detail. So a double whammy.

But once I pointed either LLM at my own previous work — the code from months of my prior personal exploration and battles for understanding, then they both worked much better. Not great, but we could make progress.

I also needed to make more mini-harnesses / scaffolds for it to work through; in other words isolating its focus, kind of like test-driven development.

We've got these sessions stored in ~/.claude ~/.codex ~/.kimi ~/.gemini ...

When you resume a session, it's reading from those folders... restoring the context.

Change something in the session, you change the agent's behavior without the user really realizing it. This is exacerbated by the YOLO and VIBE attitudes.

I don't think we are protecting those folders enough.

ETA: your link includes JIT; I’m pointing out that that’s why they don’t exist outside of the EU. Non-JIT browsers would just not be very performant.

Thanks for bringing up Meditations -- it was gifted to me three years ago. Although I roughly knew Stoicism, it was my first time reading it. It helped reaffirm my focus on OSS as a channel for personal improvement and contribution to society. With so much world chaos, probably a good time re-read it.

But he does the grifter trick of making coy observations like that 1920s bs. And he had so much time and wealth to improve those insights!

Or, he knows but this narrative makes him feel better about his behavior.

The presentation was created with Claude Code to prove itself; never going back to Keynote/PowerPoint. Press 'X' key to disable "safe mode". Prompts are in the repo.

https://neomantra.github.io/presentations/GolangMeetupJan202...

Similar to WebApps, it's only since the November'25 renaissance that I felt I could use them to create TUIs. Once I had that revelation, I started going into my backlog and using it.

I maintain a TUI Charting library, NTCharts. In January, I fixed a bug - totally obvious once identified - that I personally failed to find earlier. But the test harness, prompting, and Gemini got it done [1]. Gemini's spatial understanding was critical in completing the task.

I've been vibe-crafting a local LLM conversation viewing tool called thinkt. After scraping ~/.claude and making a data model, this is the point in PROMPTS.md where I start creating the TUI using BubbleTea. [2].

[1] https://github.com/NimbleMarkets/ntcharts/issues/7#issuecomm...

[2] https://github.com/wethinkt/go-thinkt/blob/main/PROMPTS.md#2...

I love that you made the OTel DuckDB extension last year and then were able to flex it months later for these pursuits.

The second bubble there is a tool for 3D visualization and analytics of Claude Code sessions. The sample conversation is the one that made the tool itself!

That was a fun toy I learned a lot from. I’m not expanding that but am working intensely on the first bubble:

thinkt a CLI/TUI/Webapp for exploring your LLM conversations. Makes it easy to see all your local projects, view them, and export them. It has an embedded OpenAPI server and MCP server.

So you can open Kimi and say “use thinkt mcp to look at my last Claude session in this project, look at the thinking at the end and report on the issues we were facing”.

I added Claude Teams support by launching a Team and having that team look at its own traces and the changing ~/.Claude folder. Similar for Gemini CLI and Copilot (which still need work).

Doing it in the open. Only 2 weeks old - usable, but early. I’m only posting as it’s what I’m working on. Still working on polish and deeper review (it is vibe-crafted). There’s ergonomic issues with ports and DuckDB. Coming up next is VSCode extension and an exporter/collecter for remote agents.

[1] https://github.com/AgentDank/dank-extract

[2] https://github.com/AgentDank/dank-data

I vibe-code TUI and GUI by making statements like “make the panel on the right side two pixels thinner”.

Related to this thread, I explored agentic looping for 3d models (with a swift library, could be done with this Rust one by following the workflow: https://github.com/ConAcademy/WeaselToonCadova

if you think this is impressive, I once opened a modal dialog on an Apple IIGS in 65C816 assembly

I don't think you need to learn BASIC, if you know concepts like conditionals and looping and indexing. It is interesting to compare the higher-level language of the time with its companion assembly. And you might find yourself writing BASIC programs to complement your assembly, if you stick to that platform.

<lore> A friend dropped me a BASIC program that ran and wrote text to the Apple IIGS border. He asked me to figure it out, because it wasn't obvious what was going on. OG hacker puzzle... it was a BASIC program that jumped to hidden assembly after the apparent end of the text file (hidden chars maybe, I forget) and the assembly was changing the border at appropriate rate to "draw" on it. Those were the days... trying to find some reference to this and am failing. </lore>

I certainly credit my stack-frame debugging capability to dealing with that stuff so long ago. Oddly enough, I didn't really find it helpful for computer architecture class. Just because you know registers exists and how to manipulate them, doesn't exactly map architecting modern hardware system. But being fluent in logic operations and bit-twiddling and indexing does help a lot.

She has an old MacBook and old iPhone (circa 2017?). Apple no longer updates these OS’ even the bundled Safari.

One of the bureaus, Experian I think, has a TLS cert that is not compatible with the old OSs so all the “don’t trust this site” warnings come up.

How many people have incomplete credit freezes because of this? Apple is of a size that this hurts society.

Because of course we all buy prepared foods of all sorts from street vendors to fast food to local restaurants to chains to Michelin Stars. While there are many reasons one will cook for themselves, there are many reasons one will buy from someone else too.

Now that Prometheus (the myth, not the o11y tool) has dropped these LLMs on us, I've been using this thought experiment to consider the multi-layered implications:

In a world where everyone can cook, why would anybody buy prepared food?

https://github.com/ConAcademy/reddit-kv/blob/main/README.md

For what you're saying to work, then the LLM must adhere consistently to that initial prompt. Different LLMs and the same LLM on different runs might have different adherence and how does it evolve from there? Meaning at playback of prompt #33, will the ground truth gonna be the same and the next result the same as in the first attempt?

If this is local LLM and we control all the context, then we can control that LLM's seeds and thus get consistent output. So I think your idea would work well there.

I've not started keeping thinking traces, as I'm mostly interested in how humans are using this tech. But, that could get involved in this as well, helping other LLMs understand what happened with a project up to a state.

The PROMPTS.md is communication metadata. Indeed, if you fed the same series of prompts freshly, the resultant ground truths might not make sense because of the stochastic nature of LLMs.

Maybe “ground truth” isn’t exactly the right word, but it is the consistent, determined basis which formed from past work and will evolve with future work.

I only say this as it seems one of your motivations is education. I'm also noting it for others to consider. Much appreciation either way, thanks for sharing what you did.

One suggestion, which I have been trying to do myself, is to include a PROMPTS.md file. Since your purpose is sharing and educating, it helps others see what approaches an experienced developer is using, even if you are just figuring it out.

One can use a Claude hook to maintain this deterministically. I instruct in AGENTS.md that they can read but not write it. It’s also been helpful for jumping between LLMs, to give them some background on what you’ve been doing.

I've only skimmed it, but I note that all this research is before Nov 2025 and is quite broad. It does get some into coding, mentioning GitHub CoPilot and also refers to a paper about vibe-coding, where the conclusion is that not understanding the artifacts is a problem.

So all this reporting is before Gemini 3 and Opus 4.5 came out. Everything is really different with the advent of that.

While substitute teaching just before Xmas 2025, I installed Antigravity on the student account of the class computer and vibe-coded two apps on the smart board while the kids worked on Google Classroom. This was impromptu, to liven up things, but I knew it would work because I had such amazing experiences with the tool the week before.

* [1] Quadratic Formula Explorer for Algebra 2

* [2] Proving Parallelograms for Honors Geometry

Before the class ended, I then gave a quick talk the gist was: "I just made these tools to understand the coursework by conversing with an LLM. Are you going to use this to cheat on your homework or to enhance your understanding?"

I showed it to a teacher and then she pointed me to existent tools like them on educational web sites. But that was missing the point that we can just manifest the very hyper-specific tools we need... for example how should the Quadratic Formula Explorer work for someone with dyslexia?

I'm not sure what the next steps with all this is, but certainly education needs to adapt. The paper notes "AI can enrich learning when well-designed and anchored in sound pedagogy" and what I did there is neither, so imagine how sweet it is gonna be when we weave this into educational systems by skilled curriculum designers.

[1] https://conacademy.github.io/quadratic_explorer/ [2] https://conacademy.github.io/proving_parallelograms/

* With specific positive or negative feedback, I will issue friendly complements and critiques the LLM to reinforce things I like and reduce things I don't.

* Rather than thinking sycophantic/antagonistic, I am more clear about its role. e.g "You are the Not Invented Here technologist the CEO and CTO of FirmX will bring to our meeting tomorrow. Review my presentation and create a list of shortfalls or synergies and as well as possible questions".

So don't say "please suck at your job", give them a different job.