ravila4

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.

My experience with parallel agents is that the bottleneck is not how fast we can produce code but the speed at which we can review it and context switch. Realistically, I don’t think most people have the mental capacity to supervise more than one simultaneous task of any real complexity.

It’s a similar idea, but imagine you could fire off a task, and go for a run, or do the dishes. Then be notified when it completes, and have the option to review the changes, or see a summary of tests that are failing, without having to be at your workstation.

I think one key reason HUDs haven’t taken off more broadly is the fundamental limitation of our current display medium - computer screens and mobile devices are terrible at providing ambient, peripheral information without being intrusive. When I launch an AI agent to fix a bug or handle a complex task, there’s this awkward wait time where it takes too long for me to sit there staring at the screen waiting for output, but it’s too short for me to disengage and do something else meaningful. A HUD approach would give me a much shorter feedback loop. I could see what the AI is doing in my peripheral vision and decide moment-to-moment whether to jump in and take over the coding myself, or let the agent continue while I work on something else. Instead of being locked into either “full attention on the agent” or “completely disengaged,” I’d have that ambient awareness that lets me dynamically choose my level of involvement. This makes me think VR/AR could be the killer application for AI HUDs. Spatial computing gives us the display paradigm where AI assistance can be truly ambient rather than demanding your full visual attention on a 2D screen. I picture that this would be especially helpful for help on more physical tasks, such as cooking, or fixing a bike.

This is another informative video, if you want to see the crafting process: https://www.dailymotion.com/video/x78adua

Very interested in this. I have been contemplating building something similar, but am unaware of any existing services that do this. Haven't played with pyannote, how does it compare to whisper? Also thought it might be useful to be able to OCR screenshots and use the text to inform the summariation and transcription especially for things like code snippets and domain-specifc terms.

AlphaFold is a real game-changer in predicting many protein structures, but its precision in dealing with single residue mutations, particularly in non-standard proteins, isn't a sure bet.

The tool excels because it's been trained on a massive database of known protein structures. It's great at making educated guesses based on that data, but it's not as reliable when it comes to variations that don't have much historical data, like specific mutations at the residue level.

For these finer details, traditional physics-based methods, like molecular dynamics simulations, might offer more insight. They really get into the atomic-level interactions, which can be critical for understanding the subtle effects of amino acid changes.

AlphaFold is likely to identify significant structural changes, but it might not be your go-to for pinpointing smaller, more nuanced shifts.

You may want to consider contributing to the MoreWaita (https://github.com/somepaulo/MoreWaita) theme.

This is a culture issue. If people get paid to look busy, they will find ways to look busy. There's no incentive to close tickets quickly, because it will only result in more work.

I don't see that, also on Firefox 108.0.2 (I'm using it to reply this comment.)