krychu

> but I just don't know what situation I'd reach for 3.7 Flash

You reach for it every time you do a Google search

Unfortunately reasoning ability depends on (or is enabled by) information intake during training. A model will know better what to search for and how to interpret it if the information was part of the training. So there is a trade off. Still I think the question is a practical one. Perhaps there are ideas to focus training on a) reasoning / conceptual modeling and b) reliance on external memory (search etc.) rather than internal memorization.

Self-plug. For anyone working in the terminal: https://github.com/krychu/lrn.

A very simple cli tool, consuming basic txt format. You can use it in a second window while waiting for your compilation to finish.

Recently I’ve been also experimenting with defining QA pairs in my note files (in a special section). I then use a custom function in emacs to extract these pairs and push to a file as well as Anki.

It’d be probably useful to include this very comment in your system prompt or a separate file which you ask the coding agent to read at the beginning of each session.

BDH

It’s great to read in the comments about experiences of others with vibe coding. But I also feel like lots of opinions are not coming from actual experience, or “serious” attempts at vibe coding, and more from theoretical deliberations. I might be wrong.

Here are some of my own high-level experiences / thoughts:

- Perhaps contrary to popular belief I think vibe coding will bring the best software / system architects. This is due to massively shortened feedback loop between architectural idea and seeing it in action, easiness with which it can be changed, and the ability to discuss it at any moment.

- We’re not really coding anymore. This is a new role, not a role of a senior dev reviewing PRs of junior devs. Devs are just best suited (currently) to take on this new role. I came to realization that if you’re reviewing all generated code in detail you’re doing it wrong. You just shifted bottleneck by one step. You’re still coding. You should skim if the code is in line with your high-level expectation and then make LLM maintain an architecture doc and other docs that describe what and how you’re building (this is the info you should know in detail). You can do audits with another LLM whether the implementation is 100% reflecting the docs, you can chat with LLM about implementation at any moment if you ever need. But you should not know the implementation the way you know it today. The implementation became the implementation detail. The whole challenge is to let go of the old and embrace and search for efficiency in the new setup.

- Connected to the above: reading through LLM outputs is a massive fatigue. You are exhausted after the day, because you read hundreds of pages. This is a challenge to fight. You cannot unlock full potential here if you aim at reading and reviewing everything.

- Vibe coding makes you work on the problem level much more. I never liked the phrase “ideas are cheap”. And now finally I think the tides will turn, ideas are and will be king.

- Devil is in the detail, 100%. People with ability to see connections, distill key insights, communicate and articulate clearly, think clearly, are the ones to benefit.

Hope this is helpful for others.

Thanks, appreciated

I implemented HRM for educational purposes and got good results for path finding. But then I started to do ablation experiments and came to the same conclusions as the ARC-AGI team (the HRM architecture itself didn’t play a big role): https://github.com/krychu/hrm

This was a bit unfortunate. I think there is something in the idea of latent space reasoning.

Your code dictates the compiler's behavior. If you grant the compiler flexibility, it's unreasonable to complain about unexpected results.

> The problem with c is that you must have a comprehensive dictionary in your brain with tons of corner cases to know what is or is not undefined in any given compiler setting.

The cases of undefined behavior in the C standard are independent of compiler settings or options.

> If C could have a consistent set of rules …

The C language has a well-defined standard, but the presence of undefined behavior is a deliberate aspect of that standard.

Self-plug. Here’s a fork of the original llama 2 code adapted to run on the CPU or MPS (M1/M2 GPU) if available:

https://github.com/krychu/llama

It runs with the original weights, and gets you to ~4 tokens/sec on MacBook Pro M1 with the 7B model.

Version that runs on the CPU: https://github.com/krychu/llama

I get 1 word per ~1.5 secs on a Mac Book Pro M1.

Chain of thought: https://arxiv.org/abs/2201.11903 ReAct: https://arxiv.org/abs/2210.03629 Reflexion: https://arxiv.org/abs/2303.11366 Tree of thoughts: https://arxiv.org/abs/2305.10601

Good video on "Tree of thoughts" which also reviews / puts it in the context of other methods: https://www.youtube.com/watch?v=ut5kp56wW_4

Completion vs conversational interface is something you can read about in the OpenAI API documentation.

For the remaining things I don't have single specific pointer at hand.

Using an LLM framework at this moment doesn’t make sense and can be damaging, in my humble opinion. Ways to extract value from LLMs are in early exploration stage. Look at research in prompting: chain of thought, react, reflection, tree of thoughts, zero vs few hot etc. Then completion vs conversational interfacing. Then memory management via vector databases and prompt expansion vs compression vs progressive summarization etc. All these are fairly recent developments. They are not abstractions worth cementing, this is search and creative phase. LLMs threw everything in the air, but the dust is far from settling. I think it’s important to recognize the phase we’re in and pick your weapon accordingly. You have to stay nimble and light, ready to experiment with a new idea that will come out next week. You should be hacking these things together by yourself. If you pick a framework at this stage know that the framework will have to pay the price of trying to cement things in the times of storm. And you’ll be a few steps behind. Of course this is my personal take.

Unfortunately not, “lrn” uses a very simple file format where each entry consists of three lines: question, answer, empty line. But I think it’d be a good idea to look into supporting Anki decks. I should do it some time. It’d be probably limited to decks that use text only.

I can relate to this. I had fond memory of SuperMemo on DOS and wrote a little terminal tool “lrn” inspired by it: https://github.com/krychu/lrn

I acknowledge it’s simple, runs on terminal only and lacks bells and whistles. But this is also probably why I use it so much.

Very impressive, and works well on mobile (iOS). Congrats and thanks for sharing.

From what I understand OpenAI has been moving away from “open” with various decisions over the time. Proposing that only selected folks can build AI seems like the antithesis of openness?

I've been using GPT to have (insightful) educational conversations about Quake 1 source code: https://twitter.com/krychusamp/status/1649048047996014595

I always finish up by asking GPT to test my knowledge with a single-choice questionnaire. What I've observed is that the retention of the material is higher compared to "traditional" techniques. Perhaps the conversation style is more immersive, or perhaps focusing on specific knowledge gaps makes for accelerated / personalised learning.

There is of course the problem of accuracy, but I feel like it's often over-stated. Even if GPT is not correct at times, it often uncovers concepts and relations that paint a better overall picture for me, and lead me to better questions and follow up actions.

It’s relevant. It’s harder to accept and follow a leader that can’t aim and shoot.

Shameless plug for a little tool I wrote to learn by repetition on the command line: https://github.com/krychu/lrn

I use it whenever I have a few minutes of downtime, no fancy state persistence between sessions.

That work will be done by the preprocessor and should be fairly quick given it doesn't compile the duplicated code and only removes it.

Another explanation which I found useful: https://www.gridbugs.org/wave-function-collapse/

This is a valid point. I was on the fence between doing .c/.h pair and a single .h. But finally took the inspiration from: https://github.com/nothings/stb.

Hey HN!

Part of my learning process is to use repetition techniques: just run through a deck of question & answer pairs. I wanted to have something that would run on a command-line, use a simple text format for deck files, and allow me to either type answers or think of them (just like flashcards). I deliberately didn’t want any multi-session state / management, spaced-repetition algorithms etc.

Ideally I’d write it in C but I wanted to try `ink`. It’s also my first npm package so I hope I didn’t miss anything. If you happen to try it out and run into any issues please let me know.

Thanks and enjoy!

infinitely better*

Fantastic, C99, min requirement 16Mhz! Makes me want tinker with esp32. Great lib, congrats and thank you.

This is a good research topic but my opinion differs

- The article claims that the forgetting of 90% is an underrated problem. I think it’s generally a feature that enables us to converse, read stories, and live. It’s a garbage collector. More specifically, however, it gets in the way when we learn new things. You read something important, have an aha moment, but then forget it a minute later when your short-term memory gets refilled. And so you need to run into the same important thing multiple times before it really sticks with you.

- The article claims that the time element is of upmost importance. I think it’s important only in very specific cases, and generally unimportant. The passing of time also makes the value of it decay.

- The article claims that new notes are better than re-working old ones. I feel the opposite is my preference. You re-work your knowledge, review, correct, and restructure it. What matters is your current understanding, not how you arrived there, or what your 0.1 version was. The art is in simplification and distillation over time, not accumulation.

This is fascinating. I’ve come across SuperMemo and use spaced repetition for self-created decks. However, incremental reading is something new to me, like a missing piece. Seems like it’s a process of turning any linear material into a deck. Have you or anyone else use it? And could comment on results / issues?

It’s now mostly “top 10 whatever-you-search for”, or pages that generate automated comparisons. People unconsciously craved for authentic experiences after supermarkets, and chains. And same goes for the Internet.