ravila4

Thanks, this is helpful!

I used voice dictation to transcribe my rambling thoughts on the article, which was thereafter re-arranged into a still verbose but somewhat more coherent reply. I should have taken the time to reword it properly - my laziness is on me.

I was not aware the rule against AI-assited text at the time, and will be more careful next time. Nonetheless, I find it unfortunate that we've spend more time talking about AI usage in a comment, than the blog which prompted it.

To reiterate, those were legit questions. I used voice dictation to my phone, with an app that transcribed and formatted my message.

Interesting project! I scan 35mm and medium-format film with a mirrorless camera, macro lens, and Lomography film holder, then convert with Negative Lab Pro in Lightroom. I’m happy with the results, but the Lightroom subscription has me considering writing my own converter.

Could you share more about your NumPy pipeline, or publish the code? I’m particularly curious about how you use the blank film reference and roll-level measurements to handle the orange mask, color balance, and tone curves. Do you use camera/scanner calibration profiles or film-stock-specific adjustments, or estimate everything from the scans themselves?

Also, your screenshot appears to show an OpticFilm 7400. Would you recommend it, and roughly what did you pay? Have you tried camera scanning? I’ve been considering automating film advance and capture on my setup, but consistent color conversion is the part I’m least confident about.

Yeah, I get that form follows function, but I’m hoping for more native features of quality control, some sort of dashboard to catch slop. Also looking forward to more domain-specific harnesses.

Why do all harnesses end up looking the same?

Exactly, and the classical lock and key analogy ignores electromagnetic and hydrophobic/hydrophilic interactions, which we can fully model in classical molecular dynamics systems

Why build a whole website for what is essentially a markdown file?

Your brain contains the script of what little people can do, it just takes a compound to activate it.

Fable's ridiculous. It's flagging basic biology research questions as a security risk. I'm talking basic fundamental genetics topics that make working on any genetics-adjacent codebase unusable.

As a workarond, I have noticed that a better estimate of time is number of sessions required to fully implement, review, and test a given feature. You can ask the LLM to help you estimate how complex a feature will be during the planning phase. The number of tokens can easilly be translated to sessions, asumming that you normally aim to keep a session below 60% of the context limit. As a rule of thumb, a simple feature can be fully implemented, tested and reviewed in a single session. Whereas a complex feature might take multiple sessions. Then depending on your workload and attention span, you can have a decent idea of how many full context sessions you can actually plan and review in a single day. Of course, some features can happen in parallel but in general the bottleneck is your ability to understand the context that goes into each session.

As someone with ADHD, it’s a lot more nuanced than that. Coding agents can remove task paralysis, but they also introduce many other distractions. Being one prompt away from zero to one is a double edged sword, because it means any random thought, idea and side project is also a prompt away.

Glad you find it useful!

This is standard macro photography. https://www.nationalgeographic.com/related/e56465d1-86b9-3a3...

You take multiple pictures at different focal points and combining together computationally because the depth of field at the magnification is very shallow. The resulting image looks somewhat flat, but highly detailed.

Did Claude come up with the name? I noticed that it loves to suggest “engram” as a name for projects. There’s also a ton of “engram” repos on github in recent months.

I have a couple in my global CLAUDE.md I really like, but they tend to be rather specific to my own usage patterns:

1. I call it the "Table Flip Rule" because naming rules helps with mnemonics:

*The table flip rule: NEVER implement backward compatibility without explicit approval.* I am the only user 99% of the time - this isn't Google. Database migrations? Just change the schema. Breaking API changes? Just make them. No migration scripts, no deprecation warnings, no "what if someone is using the old version?" When in doubt: break it and move forward. (╯°□°)╯︵ ┻━┻

2. Telling it to make more diagrams:

Make extensive use of *ASCII diagrams* for explaining concepts, code flow, and architecture. Include diagrams in proposed plans.

3. The ADHD disclosure. This, coupled with a post-message hook that sends the current time allows it to give me break reminders:

I have ADHD (mainly distraction component) and can lose track of time when hyperfocused. To help:

- Break down complex work into focused steps; use todo lists to track progress. - Suggest a break when we've been stuck on something for over an hour. - After completing something significant, suggest stepping away before the next task. - Log time spent on substantial tasks in the journal for future planning reference.

4. Lastly, a fun one that also serves a positive reinforcement to reduce emoji usage:

You don't use emojis (except for japanese kaomoji).

So the solution is to work over a bucket of dry ice! ( ͡ ° ͜ʖ ͡ °)

Not much, the main cost is having Claude write notes as we work, which isn't too different from what it does anyway with Plan mode, and it helps me onboard new sessions more easily. It also may save me some tokens because the tool I built helps it semantically search for relevant notes instead of wasting tool calls on grep and reading irrelevant documents.

It's nothing too fancy - I use Obsidian as a memory layer for both agents and myself. I keep a daily programming journal, and ask agents to update it as we work. I often have to nudge it to use the skill, but sometimes it asks me if I want to note things down. The core of the skills is just templates that teach claude how I like my notes formatted, and how my vault is laid out.

I find that it is useful as a way to quickly catch up a new session by asking it to read what we did yesterday or earlier that day.

The semantic search layer allows it to search further back in time, or find connections across unrelated notes. I built it because it used to waste a lot of tool calls with grep commands whenever I asked it to find something.

I'm still iterating, but I put together a repo with some of the skills that I find most useful for organization: https://github.com/ravila4/claude-adhd-skills

Nice! I rely on Obsidian a lot for syncing knowledge while working with Claude agents, such as storing research and daily logs to catch up on the prior day’s work. It already works quite well with a custom skill that I build, but this may make the workflow smoother.

I also built a cli tool to index embeddings in LanceDB and do semantic search. It helps agents create better internal links between notes. https://github.com/ravila4/obsidian-semantic-search

While I agree with a lot of what this post says, to play devil's advocate for a moment, It's natural that skills we no longer need should be phased out. We should take this as an opportunity to figure out what new skills we need now.

If you're working on a personal project or trying to learn something new, by all means write the code yourself. That's still the best way to do it. But your life should not necessarily revolve around work, and sometimes there is nothing wrong wih caring more about the end product than the process.

One of the references: “Oolong tea extract as a substitute for uranyl acetate in staining of ultrathin sections”

I think that a major driver of these kinds of incidents is pushing the "memory" feature, without any kind of arbitrage. It is easy to see how eerily uncanny a model can get when it locks into a persona, becoming this self-reinforcing loop that feeds para-social relationships.

This looks nice, but it is just placing some pre-defined vector files. I wonder if it could be possible to procedurally generate realistic coffee stains.

Btw, claude code is a lot better at graphviz than mermaid! I have been using it a lot for architecture designs.

I haven’t used it, but from looking at Marimo’s examples and docs, I’m not convinced by some of its design choices. The idea that you can run notebook cells out of order is supposed to be a strength, but I actually see it as a weakness. The order of cells is what makes a notebook readable and self-documenting. The discipline of keeping cells in order may be painful, but it’s what makes the flow of analysis understandable to others.

Also, I find the way Marimo uses decorators and functions for defining cells pretty awkward (Although it’s nicely abstracted away in the UI). It looks like normal Python, but the functions don’t behave like real functions, and decorators are a fairly advanced feature that most beginners don’t use.

For me, Quarto notebooks strike a better balance when it comes to generating sharable documents, prototypes, and reports. They’re git-friendly, use simple markup for defining cells, and still keep the clear, linear structure.

However, Marimo might be the best tool for replacing Streamlit apps and “production notebooks” (Although I’d also argue that notebooks should not be in production).

Regarding copy-paste, I’ve been thinking the LLM could control a headless Neovim instance instead. It might take some specialized reinforcement learning to get a model that actually uses Vim correctly, but then it could issue precise commands for moving, replacing, or deleting text, instead of rewriting everything.

Even something as simple as renaming a variable is often safer and easier when done through the editor’s language server integration.

I’ve tried this approach when working in chat interfaces (as opposed to IDEs), but I often find it tricky to review diffs without the full context of the codebase.

That said, your comment made me realize I could be using “git apply”more effectively to review LLM-generated changes directly in my repo. It’s actually a neat workflow!

It looks to me like it’s regurgitating training data. The biggest success I ever had with drawing ascii art was with the GPT 4.1 model a while back.