supermdguy

I think there's still value in building quality products, but AI makes it easy to build something that appears good but doesn't actually work that well. It's very difficult to communicate the thought and intentionality that went into a well-designed product in a way that stands out amongst the noise.

Has anyone had success using skills like these without an agent that supports them? I’m using the Zed agent, which doesn’t have skills support, and was thinking of just adding in a summary of the skills directory and how to use it inside my AGENTS.md.

Looks like this would affect around 4.3% of chats (the "Self-Expression" category from this report[0]). Considering ChatGPT's userbase, that's an extremely large number of people, but less significant than I thought based on all the talk about AI companionship. That being said though, a similar crowd was pretty upset when OpenAI removed 4o, and the backlash was enough for them to bring it back.

[0]: https://www.nber.org/system/files/working_papers/w34255/w342...

That's a good point, thinking about it some more, I think the business logic feels so trivial that it would make the code harder to reason about if it were separated from the effects. Currently, I have one giant function that pulls data, filters it, conditionally pulls more data, and then maybe has one line of effectful code.

I could have one function that pulls the wallet balance for all users, and then passes it to a pure function that returns an object with flags for each user indicating what action to take. Then another function would execute the effects based on the returned flags (kind of like the example you gave of processing a pending charges table).

The value of that level of abstraction is less clear though. Maybe better testability? But it's hard to justify what would essentially be tripling the lines of code (one function to pull the data, one pure function to compute actions, one function to execute actions).

Additionally, there's a performance cost to pulling all relevant data, instead of being able to progressively filter the data in different ways depending on partial results (example: computing charges for all users at once and then passing it to a pure function that only bills customers whose billing date is today).

Would be great to see some more complex examples of "functional core imperative shell" to see what it looks like in real-world applications, since I'm guessing the refactoring I have in my head is a naive way to do it.

Typescript, using Zod with Express for parameter validation.

> A common pattern would be to separate pure business logic from data fetching/writing. So instead of intertwining database calls with computation, you split into three separate phases: fetch, compute, store (a tiny ETL). First fetch all the data you need from a database, then you pass it to a (pure) function that produces some output, then pass the output of the pure function to a store procedure.

Does anyone have any good resources on how to get better at doing "functional core imperative shell" style design? I've heard a lot about it, contrived examples make it seem like something I'd want, but I often find it's much more difficult in real-world cases.

Random example from my codebase: I have a function that periodically sends out reminders for usage-based billing customers. It pulls customer metadata, checks the customer type, and then based on that it computes their latest usage charges, and then based on that it may trigger automatic balance top-ups or subscription overage emails (again, depending on the customer type). The code feels very messy and procedural, with business logic mixed with side effects, but I'm not sure where a natural separation point would be -- there's no way to "fetch all the data" up front.

How do you guys share types between your frontend and backend? I've looked into tRPC, but don't like having to use their RPC system.

Reading the code, I was surprised to see that cd was implemented by calling out to the os library. I assumed that was something the shell or at least userspace handled. At what level does the concept of a “current directory” exist?

If your output schema doesn’t capture all correct outputs, that’s a problem with your schema, not the LLM. A human using a data entry tool would run into the wrong issue. Letting the LLM output whatever it wants just makes it so you have to deal with ambiguities manually, instead of teaching the LLM what to do.

I usually start by adding an error type that will be overused by the LLM, and use that to gain visibility into the types of ambiguities that come up in real-world data. Then over time you can build a more correct schema and better prompts that help the LLM deal with ambiguities the way you want it to.

Also, a lot of the chain of thought issues are solved by using a reasoning model (which allows chain of thought that isn’t included in the output) or by using an agentic loop with a tool call to return output.

Really like the philosophy, and the UI looks clean. You mentioned grammar briefly, but I’m curious if you think that’s also a component that could be learned through the app? One thing that’s nice about Duolingo (despite its flaws) is that it progressively introduces new grammar concepts and uses them in the lessons. Would be cool to have something similar here.

That corresponds to a 10/15, which is actually really good (median is around 6)

https://artofproblemsolving.com/wiki/index.php/AMC_historica...

Interesting work. Not super familiar with neural architecture search, but how do they ensure they’re not overfitting to the test set? Seems like they’re evaluating each model on the test set, and using that to direct future evolution. I get that human teams will often do the same, but wouldn’t the overfitting issues be magnified a lot by doing thousands of iterations of this?

Just guessing, but the new Opus was probably RL tuned to work better with Claude Code's tool calls

How does your tool library work? Who organizes it? Sounds really interesting.

Most providers will just end the chat if it reaches the max context window.

clippings.io has a browser extension that scrapes all your highlights from Amazon's website and lets you download them in various formats.

Code is available! They have a few different discovered solutions.

https://github.com/google-deepmind/funsearch

I love using Anki to stay organized with what I'm learning, but hate starting at a screen for a long time. So I made a system that reads the cards out loud and automatically grades them, using Anki for the card storage/scheduling.

Tech Stack:

Text-To-Speech: ElevenLabs/OpenAI

Speech-To-Text: Faster-Whisper (I used the tiny.en model, about 0.5s latency on my M1 mac)

Language Model: ChatGPT (I used gpt-3.5-turbo-1106)

Others: PyWebView, Silero VAD

The direct prompt comparison isn't quite fair due to the instruction tuning on GPT-3.5 and 4. It'd be interesting to see examples with prompts that would work better for the raw language models.

GPU memory bandwidth is a limiting factor for how fast training can happen, so it’s much more efficient to train models on locally connected high memory GPUs.

Also gradient updates from all nodes would need to get combined at least every few training steps, and it would take a while to sync all gradient updates across the network.

There's a great short story by Ted Chiang that explores a similar idea: https://waldyrious.neocities.org/ted_chiang/liking-what-you-.... It's interesting to think about how much attractiveness plays into the way the world works.

I used diff2html, it's really nice!

https://github.com/rtfpessoa/diff2html-cli

Yep, here’s an example of what a report looks like: https://tosnotify.com/reports/example

I tried it for the example, but it wasn't very good at differentiating between the old and new changes. I'm definitely going to try to see if I can get some good outputs though.

I like this! Focusing on enterprise probably makes more sense since terms matter more for compliance.

I honestly don't think I've ever read one of the ToS updates either. Do you think there'd be a way for them to be more relevant?

Thanks for the support! I sent you a dm

Those are both good ideas! Someone else suggested using account lists in password managers. In general it would be a lot more practical if it could feed from a list of accounts you have.

It works for any online document! Right now it just generates a diff of any URL: https://tosnotify.com/reports/example. In the future it'd be cool if it could auto-detect TOS/Privacy Policy links for a given domain.

I've been thinking through how this could work more practically, and this definitely makes the most sense. I might try to find an easy way to export just a list of sites that I have accounts on and then watch those for TOS changes.