Hacker Newsnew | past | comments | ask | show | jobs | submit | t-kalinowski's commentslogin

Seeing that list of tools you're using in automations, I'm guessing you'll enjoy this, as another tool to add to the pile: https://t-kalinowski.github.io/yamark/

(disclosure: I wrote it)


Well, there goes my weekend. Thanks for sharing. Will take a look.


One project I’d add to the comparison is raghilda from Posit:

https://posit-dev.github.io/raghilda/

raghilda is deliberately narrower than LangGraph/Haystack/etc. It focuses on the RAG parts: document ingestion, chunking, embedding, storage, and retrieval. It’s meant to leave the pieces visible and replaceable rather than wrap the whole application in a framework.

It also composes well with the other parts of the Posit ecosystem: chatlas for LLM interaction, and Shiny for building interactive apps around the result.

My bias is that orchestration is often better hand-rolled for the specific application. Once the framework gets too far removed from the actual steps, it tends to bring in a lot of complexity you probably don’t need. In the end, most of these pieces are not that complicated.

Disclosure: I’m one of the authors of raghilda.


I wonder if YAML is better than JSON for LLMs, because the indentation keeps the nesting level information local to the content.


Because YAML is the worst config format, except for all the others.

https://opensource.posit.co/blog/2026-05-21_in-defense-of-ya...


Seems like that article is saying that YAML 1.1 is bad, but 1.2 is good? Which would be fine, except I am parsing YAML 1.1 files (as indicated by a directive at the top). I don't control the format of the data


Memories are failable :) Here is the PR you merged June of last year, changing the file extension from `.qmd` to `.qd` after a discussion about Quarto: https://github.com/iamgio/quarkdown/pull/90


Of course, just saying I'm not familiar with the language itself and its capabilities! :)


Counterpoint from a doctor: https://substack.com/inbox/post/189714240

Scribes _feel_ good in the short-term, but it's not clear if they're actually good on longer time horizons.


In an article critiquing over-use of AI assistants, the author confesses at the end this article itself was authored partly by Claude that introduced errors in the citations, lol.

Nonetheless, I come away from this article with the sense the ambient devices automating documentation of an encounter are still a net win, with caveats about the need for the doctor to polish the note ti reflect his or her own narrative voice.


> Counterpoint from a doctor: https://substack.com/inbox/post/189714240

That article is clearly LLM-assisted if not vibe-written, which is the height of irony given the context.

Note that the CIO is talking about patient satisfaction, which is a distinct target. I agree about the long-run benefit being unclear.


"I am not saying ambient scribes are bad technology."

is this a counterpoint? he just seems to be wary of the risk, without a firm position and decided to personally stop using it. people often overestimate their own skills and think their own charting is better than that of others, that doesn't mean the tech doesn't work.


I think every single provider should evaluate them for themselves. Some providers are absolutely better of without them and we don't make anyone use them.


the two places they come in handy:

1) in the event you find yourself partially or totally disabled but the records don’t really make a good case for it and your provider has a dismissive attitude about filling out additional documentation to substantiate what they failed to in your records.

You’re not necessarily going to get approved for FMLA, STD, LTD, SS etc based on a diagnosis or test results alone. They will nitpick over say, heart failure, as if that’s magically and spontaneously going to go away. If you’re telling your provider that you’re limited by things like oh I don’t know, “I’m only awake for 2-4 hours before I need to sleep again” or “some days I just can’t do it and sleep 20 hours” but it’s not in your chart… expect denials and clarifications and a huge burden on you to prove why it’s limiting.

2) continuity of care, so you don’t end up explaining everything from the top to a specialist or having them run all these tests and procedures from square one — when there’s months long backlogs , and we already did all this and you need treatment - but - there wasn’t much to work with in your referring chart.

You might not appreciate the “intrusion” if you’re healthy and just worried about your privacy.

If/When things go south and you find yourself fighting these entities for a year or two or three while they nitpick and delay and deny and drag their feet , you’ll be glad an “AI” kept up meticulous records because this is phenomenally stressful and an endless burden on you when they don’t.

So, their AI slop can vomit out all this extra info on why insurance companies should pay them or why your condition is in fact disabling, and now their AI slop can comb through it looking for all that. Because they will try to avoid paying or approving any kind of leave or benefits if it’s not there

And god forbid you hand them a form where they’re being asked to explain themselves. 50/50 on them being eager to help out or rolling their eyes and saying something really nasty about the imposition. And then even when they do that, they almost never file a copy in your chart so your chart STILL doesn’t substantiate your claims. I’m all for an “ai” doing the progress notes in a case where the facility or provider can’t be fucked to do so.

Happily that’s not true of my current provider, who just, does that anyway (?) But I’ve been around enough to know they’re an exception. Even when providers are on your side and mean well, and want to bend over backwards to help you in any way they can — and I want to just acknowledge that’s the situation I’m in today — honestly , sometimes they just forget some of the details when they do their notes.

That’s why some places make the provider do it in real time while they’re talking to you, so they didn’t forget something relevant thirty minutes later. The other side of the coin here may be that some providers find that distracting or off putting to be typing away like a stenographer while they’re examining you…

I think it would be fair to say this can all be tedious and a burden for both patients and providers. There’s just a world of difference between a provider who wants to do this to provide excellency in care, and a provider who wants to do this because they resent it and think it’s beneath them.


Very cool!

We’ve been exploring a similar direction too, but with a plain REPL and a much thinner tool surface. In our case, it’s basically one tool for sending input, with interrupts and restarts handled through that same path. Marimo seems to expose much richer notebook structure and notebook-manipulation semantics, which is a pretty different point in the design space.

It seems like the tradeoff is between keeping the interaction model simple and the context small, versus introducing notebook structure earlier so the model works toward an artifact at the same time it iterates and explores. Curious how you think about that balance.

Repo: https://github.com/posit-dev/mcp-repl


Thanks for sharing!

I think the tradeoff is less stark than it seems. Our tool surface is also basically just "run Python", but the model may additionally use a semi-private API ("code mode") within that execution context to inspect and modify the notebook itself. So the notebook structure isn't something the model has to manage. Marimo's reactivity handles the graph automatically, and the model gets artifact construction as a side effect of exploration.

Where I'd imagine the approaches diverge more is in what the runtime gives back. In a plain REPL, the model carries state in its context. In marimo, it can offload state to the notebook and query it back: inspect variables, read cell outputs, check the dependency graph. That turns the notebook into working memory the model can use without it all living in the conversation. Over longer sessions especially, that matters.


interesting, i also went the same direction with https://github.com/danieltanfh95/replsh because i needed to support existing legacy python codebases.


I agree that at first glance, it seems like tmux, or even long-running PTY shell calls in harnesses like Claude, solve this. They do keep processes alive across discrete interactions. But in practice, it’s kind of terrible, because the interaction model presented to the LLM is basically polling. Polling is slow and bloats context.

To avoid polling, you need to run the process with some knowledge of the internal interpreter state. Then a surprising number of edge cases start showing up once you start using it for real data science workflows. How do you support built-in debuggers? How do you handle in-band help? How do you handle long-running commands, interrupts, restarts, or segfaults in the interpreter? How do you deal with echo in multi-line inputs? How do you handle large outputs without filling the context window? Do you spill them to the filesystem somewhere instead of just truncating them, so the model can navigate them? What if the harness doesn’t have file tools? And so on.

Then there is sandboxing, which becomes another layer of complexity wrapped into the same tool.

I’ve been building a tool around this problem: `mcp-repl` https://github.com/posit-dev/mcp-repl

So tmux helps, but even with a skill and some shims, it does not really solve the core problem.


Posit offers something similar to Microsoft’s CRAN Time Machine, but it works not only for CRAN, but also for Bioconductor and PyPI. You can add a date to the Public Posit Package Manager URL to access a snapshot of all packages from that day.

For example: https://packagemanager.posit.co/cran/2025-03-02

You can browse available snapshot dates here: https://packagemanager.posit.co/client/#/repos/cran/setup?sn...

This also works for PyPI and Python packages: https://packagemanager.posit.co/pypi/2025-03-04/simple


Or, don't even write the fortran manually, just transpile the R function to fortran: https://github.com/t-kalinowski/quickr


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: