anonymid

https://dlants.me/bloom.html

Blooms 2 sigma, like many studies that are thrown about, is not as much of a slam dunk as people claim that it is. Have you read the paper or any efforts to replicate?

I wrote my own neovim AI harnesshttps://github.com/dlants/magenta.nvim

And wrote about my thoughts on the relevance of nvim here https://dlants.me/ai-whiplash.html

It's been many months, and I thoroughly prefer my harness inside of nvim as my day to day development environment. Using Claude code or cursor makes me feel very removed from the code.

Exploring code, gathering context and tweaking prompts/giving guidance to the agent are very much enhanced by neovim.

The biggest boon has been the fact that agents make customizing neovim a lot easier. Writing new bindings, config, and even building novel plugins.

Here's a few that I built that fit into my workflow:

- a tool for reviewing commits / branches / wip. https://github.com/dlants/glean

- an iterative grepper https://github.com/dlants/shuck

- a file picker that renders in your current window (like oil) and uses more intelligent signals for ranking (like frecency) https://github.com/dlants/needle

Plugging away at my neovim AI plugin - https://github.com/dlants/magenta.nvim

Recently added support for scripts (like Claude code workflows) and been iterating on the UI for that a bunch.

I also ended up wanting other customized tooling - a more streamlined way to grep, find files and review code that my agent has written. So I wrote a few plugins for that : needle (finder with UI and sorting functions that suit me better), shuck (interactive grepper that has a workflow around refining grep commands) and glean (a review tool that lets you mark parts of the code as seen, leave comments, view diffs commit by commit or collapsed, etc). https://github.com/dlants/dotfiles/tree/main/nvim/lua

These are all in various states of experimental and mostly just for me, but a few of my coworkers and friends have been using magenta and like it.

I don't think the S&P has actually made a decision yet. It is in progress, though: "The S&P Index Consultation on MegaCap IPOs" is the search term

I guess the hope is that combining two sub-par coding models (xAI's grok + cursor's composer) and combining the data they have access to, they can build something that can compete with OpenAI / Anthropic in the coding space...

I guess I kinda see it... it makes sense from both points of view (xAI needs data + places to run their models, cursor needs to not be reliant on Anthropic/OpenAI).

I think I don't see it working out... I just don't see an Elon company sustaining a culture that leads to a high-quality AI lab, even with the data + compute.

I've been developing an ai coding harness https://github.com/dlants/magenta.nvim for over a year now, and I use it (and cursor and claude code) daily at work.

Fun observation - almost every coding harness (claude code, cursor, codex) uses a find/replace tool as the primary way of interacting with code. This requires the agent to fully type out the code it's trying to edit, including several lines of context around the edit. This is really inefficient, token wise! Why does it work this way? Because the LLMs are really bad at counting lines, or using other ways of describing a unique location in the file.

I've experimented with providing a more robust dsl for text manipulation https://github.com/dlants/magenta.nvim/blob/main/node/tools/... , and I do think it's an improvement over just straight search/replace, but the agents do tend to struggle a lot - editing the wrong line, messing up the selection state, etc... which is probably why the major players haven't adopted something like this yet.

So I feel pretty confident in my assessment of where these models are at!

And also, I fully believe it's big. It's a huge deal! My work is unrecognizable from what it was even 2 years ago. But that's an impact / productivity argument, not an argument about intelligence. Modern programming languages, IDEs, spreadsheets, etc... also made a fundamental shift in what being a software engineer was like, but they were not generally intelligent.

Hey, thanks for responding. You're a very evocative writer!

I do want to push back on some things:

We treat "cognitive primitives" like object constancy and causality as if they are mystical, hardwired biological modules, but they are essentially just

I don't feel like I treated them as mystical - I cite several studies that define what they are and correlate them to certain structures in the brain that have developed millennia ago. I agree that ultimately they are "just" fitting to patterns in data, but the patterns they fit are really useful, and were fundamental to human intelligence.

My point is that these cognitive primitives are very much useful for reasoning, and especially the sort of reasoning that would allow us to call an intelligence general in any meaningful way.

This "all-at-once" calculation of relationships is fundamentally more powerful than the biological need to loop signals until they stabilize into a "thought."

The argument I cite is from complexity theory. It's proof that feed-forward networks are mathematically incapable of representing certain kinds of algorithms.

Furthermore, the obsession with "fragility"—where a model solves quantum mechanics but fails a child’s riddle—is a red herring.

AGI can solve quantum mechanics problems, but verifying that those solutions are correct still (currently) falls to humans. For the time being, we are the only ones who possess the robustness of reasoning we can rely on, and it is exactly because of this that fragility matters!

Thanks for reading, and I really appreciate your comments!

who feed their produced tokens back as inputs, and whose tuning effectively rewards it for doing this skillfully

Ah, this is a great point, and not something that I considered. I agree that the token feedback does change the complexity, and it seems that there's even a paper by the same authors about this very thing! https://arxiv.org/abs/2310.07923

I'll have to think on how that changes things. I think it does take the wind out of the architecture argument as it's currently stated, or at least makes it a lot more challenging. I'll consider myself a victim of media hype on this, as I was pretty sold on this line of argument after reading this article https://www.wired.com/story/ai-agents-math-doesnt-add-up/ and the paper https://arxiv.org/pdf/2507.07505 ... who brush this off with:

Can the additional think tokens provide the necessary complexity to correctly solve a problem of higher complexity? We don't believe so, for two fundamental reasons: one that the base operation in these reasoning LLMs still carries the complexity discussed above, and the computation needed to correctly carry out that very step can be one of a higher complexity (ref our examples above), and secondly, the token budget for reasoning steps is far smaller than what would be necessary to carry out many complex tasks.

In hindsight, this doesn't really address the challenge.

My immediate next thought is - even solutions up to P can be represented within the model / CoT, do we actually feel like we are moving towards generalized solutions, or that the solution space is navigable through reinforcement learning? I'm genuinely not sure about where I stand on this.

I don't have an opinion on this, but I'd like to hear more about this take.

I'll think about it and write some more on this.

$2700/mo is about 1/3 of an engineers' salary (cost to the business of a mid-level engineer in the UK)...

But, there's the time to set all of this up (which admittedly is a one-time investment and would amortize).

And there's the risk of having made a mistake in your backups or recovery system (Will you exercise it? Will you continue to regularly exercise it?).

And they're a 3-person team... is it really worth your limited time/capacity to do this, rather than do something that's likely to attract $3k/mo of new business?

If the folks who wrote the blog see this, please share how much time (how many devs, how many weeks) this took to set up, and how the ongoing maintenance burden shapes up.

For folks who use neovim, there's always https://github.com/dlants/magenta.nvim , which is just as good as claude code in my (very biased) opinion.

magenta nvim

magenta nvim implements a really nice integration of coding agents.

You can see a gif of it in the readme https://github.com/dlants/magenta.nvim?tab=readme-ov-file

I added next-edit-prediction to my neovim plugin.

This was pretty interesting to implement!

- I used an [lsp server](https://github.com/dlants/magenta.nvim/pull/162/files#diff-3...) to track opened files and aggregate text changes to get a stream of diffs.

- I then feed that along with the [context surrounding the cursor](https://github.com/dlants/magenta.nvim/pull/162/files#diff-1...), and a [system prompt](https://github.com/dlants/magenta.nvim/pull/162/files#diff-a...) into an LLM, [forcing a tool use for a find/replace within the context window](https://github.com/dlants/magenta.nvim/pull/162/files#diff-1...)

- Finally, I show the find/replace in the buffer using [virtual text extmarks](https://github.com/dlants/magenta.nvim/pull/162/files#diff-1...), applying a comment effect to the added sections, and a strikethrough to the removed sections

One thing that is interesting about this is that I wasn't able to get good results from smaller/faster models like claude haiku, so I opted to use a larger model instead. I found that the small delay of about a second was worth it for more consistent results.

I also opted to have this be manually triggered (Shift-Ctrl-l by default in insert or normal mode). This is a lot [less distracting](https://unstable.systems/@sop/114898566686215926).

One cool thing is that you can use a plugin parameter, or a project-level parameter to [append to the system prompt](https://github.com/dlants/magenta.nvim/blob/main/node/option...). I think by providing additional [examples of how you want it to behave](https://github.com/dlants/magenta.nvim/blob/main/node/provid...), you can have it be a lot more useful for your specific use-case.

I never got the valuation. I (and many others) have built open source agent plugins that are pretty much just as good, in our free time (check out magenta nvim btw, I think it turned out neat!)

I recently finished some updates to my neovim ai plugin: - context tracking - multiple threads - compaction - sub-agents

I decided to record a video of myself using the plugin to implement another feature. Aside from a demo of the plugin itself, I think it's a good view into what a typical workflow of using AI for development might look like, and I think is a good illustration of what these agents can and cannot currently do.

Find out more here: https://github.com/dlants/magenta.nvim

I do have a bias, and I don't think that negates the points. I think that's the benefit of establishing a common factual basis. You can argue with the bias by presenting competing facts, or a different interpretation of the facts, but at least we can agree on what we're starting with.

I think the question is - why is the national guard and the military being sent to CA without the governor's consent?

Part of the justification for this from the administration is that the riots are out of control, are posing an immediate risk of violence and property damage. Based on what I've found of the actual violence and damage being done, this justification does not hold up, as the violence and property damage are lower than previous protests in which there didn't seem to be a need for interference.

The rule of law is a different argument. What is the rule of law that is being undermined? I think here too you can have an argument about the operations that ICE is conducting, are they lawful - given that they are being conducted in sanctuary cities? Who has jurisdiction in this case? Is the administration lawful in sending in the national guard without the consent of the governor? What about the military? Newsom is now suing Trump over deploying the marines and the national guard despite his wishes, so there is a claim that such actions were unlawful.

Based on my brief research into this, ICE was operating in an unconstitutional way and making many procedural violations. City Sancutary status is lawful and has been upheld in the court of law. Newsom's challenge of Trump's deployment of the National Guard also held up in court. [link](https://claude.ai/public/artifacts/99a64b2d-e3b6-4d37-956f-c...)

When you say that "the law is being attacked" in this case, what do you mean?

neovim has AI integration! (and a pretty damn good one if I say so myself (I wrote it))

https://github.com/dlants/magenta.nvim

I agree - there seems to be talking past each other about some very fundamental things:

How extensive is the violence of the protests? I saw some images shared of cars that were burned, maybe some buildings damaged. But also lots of images from other protests from previous years. Are the images of the same 3 cars and storefronts or many? Trump says the riots are out of control, Newsom says the protests are largely peaceful.

A basic claude search suggests the overall level of violence is moderate, and smaller than many recent protests [link](https://claude.ai/public/artifacts/ef220c3d-c6d9-4b4b-bb3f-2...)

How much of a strain do undocumented immigrants place on the US? You can answer this question from a financial and criminal point of view. From the point of view of crime, Trump and ICE are parading every violent undocumented immigrant they can, but that is not statistics. Do undocumented immigrants account for a significant portion of violent crime in the country?

Studies overwhelmingly show that undocumented immigrants are significantly less violent than the general population [link](https://claude.ai/public/artifacts/a92623b8-5c02-4c3a-84ae-f...)

From a financial point of view, what resources are undocumented immigrants straining, and is it to a significant degree?

The economic picture is much more nuanced. On the cost side, a criticized study (FAIR) reported the cost at about $182bn annually (this is likely an over-estimate). For comparison, undocumented immigrants pay about $100bn in taxes, boost the GDP, and create jobs. Mass deportation is estimated to cost $315Bn.

Studies show that the impact on wages is small.

The biggest cost factor ($78bn but estimates vary) seems to be K-12 education, and that is mostly born by states. [link](https://claude.ai/public/artifacts/29f10fcf-c8a7-4655-979f-b...).

There are lsp tools available to the agent, so in theory it should be able to ask for types, references and diagnostics.

In using it I've found that the agent doesn't really make use of these tools unless I instruct it to. I think I need to do some messing around with prompts to encourage the agent to use them more.

I think the next major thing I want to add is commands to allow you to send symbol types / diagnostics to the agent before it asks for them, which should help speed up some of these workflows.

Thanks for the pointer to take another look at aider - the DIFF format sounds really interesting. Though it seems like the license is Apache 2.0 so I think I'll have to learn a bit about what that means since I made mine MIT licensed.

The interface for a provider does abstract over this, so you could implement it in the way that most other plugins do by rolling your own prompts and parsing: https://github.com/dlants/magenta.nvim/blob/main/node/provid...

But yeah... it probably would take substantially more effort and be more brittle than having the model providers do it for you.

I'm happy to accept PRs if folks want to go for it :)

Isn't it inconsistent to both say "moderation decisions are about behavior, not content", and "platforms can't justify moderation decisions because of privacy reasons".

It seems like you wouldn't need to reveal any details about the content of the behavior, but just say "look, this person posted X times, or was reported Y times", etc... I find the author to be really hand-wavy around why this part is difficult.

I work with confidential data, and we track personal information through our system and scrub it at the boundaries (say, when porting it from our primary DB to our systems for monitoring or analysis). I know many other industries (healthcare, education, government, payments) face very similar issues...

So why don't any social network companies already do this?

I made a little activity from the demonstration given in the paper,

https://teacher.desmos.com/activitybuilder/custom/59a05b5f50...

I agree that the actual paper is way better than most press I've read about it. (others have linked to it, but http://www.sciencedirect.com/science/article/pii/S0315086017... )

I found the surprise appearance by Knuth super interesting!

I wouldn't mind paying more taxes in order to provide others with something I consider a human right.

Under single-payer, CA employers will no longer need to provide insurance for their employees. That money could in some way pay for this. It also makes the idea of a 'gig economy' much more palatable, since people working in short-term / part-time situations will no longer have to go without employer-provided insurance. It could be a source of further economic growth since that makes CA a much more friendly place to start a business.

More centralized healthcare systems also have two arguments for driving down cost - one being that such a system is more effective at promoting timely / preventative care (which is a lot cheaper than emergency care). The second is that such a system can negotiate prices with providers more effectively, and invest in long-term projects to reduce the cost of care, driving down the cost of healthcare overall.

For the uninitiated, is there somewhere where I can read about Ember tooling? What are the pieces of tooling that you particularly rely upon?

My attempt at "bread" http://imgur.com/a/SMWm9

Those too are hate crimes, and are deplorable. However I don't understand the point you are trying to make.

TLDR: This seems to be a strawman, at least in how it presents common core. However, I have to give a concession to the criticism that superficial understanding is often what common core implementations look like. Still, in my opinion fluency comes from understanding, not the other way around.

The problem with focusing relentlessly on understanding is that math and science students can often grasp essentials of an important idea, but this understanding can quickly slip away without consolidation through practice and repetition. Worse, students often believe they understand something when, in fact, they don’t. By championing the importance of understanding, teachers can inadvertently set their students up for failure as those students blunder in illusions of competence. As one (failing) engineering student recently told me: “I just don’t see how I could have done so poorly. I understood it when you taught it in class.” My student may have thought he’d understood it at the time, and perhaps he did, but he’d never practiced using the concept to truly internalize it. He had not developed any kind of procedural fluency or ability to apply what he thought he understood.

Teaching for understanding means that teachers are responsible for ensuring that students are understanding. If a student is mistaken about understanding something, but the teacher doesn't probe their understanding to expose their misconceptions, that's not "teaching for understanding".

Common core encourages repetition through its focus on multiple representations. One might study linear growth as repeated adding, as a table, as a graph, and in applications to various real-life phenomena. Common core places emphasis on the student being fluent (as the author states, common core has fluency as one of its three major focal points) with all of these representations, and also in seeing the connections between them. This repeated exposure brings out misconceptions, builds understanding, and (over time) results in fluency.

I really don't see why the author has a bone to pick with common core since the sort of practice she describes would fit perfectly into a common core curriculum:

I memorized the equation so I could carry it around with me in my head and play with it. If m and a were big numbers, what did that do to f when I pushed it through the equation? If f was big and a was small, what did that do to m? How did the units match on each side?

Common core (and contemporary education movements) are against "rote" or "procedural" learning. They would be against making up a song to memorize f=ma, and merely using that song to plug-and-chug through a small collection of problem types.

One recent example I saw (a colleague works on coaching teachers in common core) was a class of elementary students who could correctly multiply 4/7 * 5/9, but couldn't shade in 1/4 of a square. They memorized and rehearsed the procedure for multiplication, but never built understanding of what they were doing.

The unfortunate thing is that they are able to demonstrate fluency in this skill - and they will likely score well on standardized tests as a consequence of this fluency. This skill, however, is shallow - and will be easily forgotten without continued practice. Furthermore, when the time comes to learn proportional reasoning, or rates of growth, or any other thing that has to do with fractions, they will have nothing to build their understanding on.

I have to make a concession to the author, however. It is easy to get this impression of common core from the sidelines. Most teachers, departments, and schools were dumped into the core (which is merely a set of standards) without much support or training. Implementing the core requires a major shift in how one approaches teaching, and whether it is due to a lack of understanding, a lack of will, or most likely - a lack of resources, many classrooms are merely cargo-culting the sorts of things that common core demands.

My favorite introductory book to the subject is https://amzn.com/0325052875 happy to chat!

I was frustrated by this article because I find it taking for granted the idea that math is only accessible to a small group of people - 'talented, gifted, with an affinity for, confluence of specific abilities'. I find similar language around programs like the Russian School, Brilliant and quite obviously the 'gifted' programs.

Yet in this article they quote the following statistics:

- High achievement in math: US 9% to SK 30% - Ratio of high achievers affluent vs poor: US 8 to 1, SK 3 to 1

These statistics communicate to me that half of all students are capable of high achievement in mathematics. From my experience tutoring and visiting classrooms of various grade levels and demographics, most students are capable of the rich problem solving described in the article.

US education's biggest issue is social justice. We spend the least resources on the children who need it most. It's funny to me that the closing of this article suggests that it's time for the advanced mentors to step in to the public education scene. What would a group of people that cater primarily to the best-served students in the system have to say about how to help the worst-served? What would they know about the obstacles faced by poor children and parents; overworked, undertrained and unsupported teachers; and underfunded schools?