Vibe coding vs agentic coding (Ralph Wiggum loop)

Offtopic
1

EDIT: I’ve shortened this post, still will edit it more, see history if you want all of it. My main point here is an FYI on what AI is already capable of, like making the Rue/language/compiler, and asking people what they are actually doing with AI with or without Julia, and how.

Continuing the discussion from Julia is one of the most token-efficient programming languages:

I would like to know how many here are vibe coding, or agentic coding, with good results in Julia or other languages, and subjective feeling of which programming language, and what tools to use with feel best.

E.g. C# is one of the best languages on the metric shown there, but it’s known to be ranked rather low on token efficiency (not same as verbosity of generated code, maybe correlated?).

[It’s revealed where Julia is ranked at 11:19, on that metric (which does not align with token efficiency) and it’s worth to watch at least up to that point ]

Don’t underestimate vibe coding, Karpathy went from reviewing 80% to reviewing 20%, yes still not 0% as for some others, of the generated code. Even Linus Torvalds is now vibe coding in Python; and Steve, of Rust fame, making a new language alone (or well with Claude), 130.000 lines in two weeks:

You may know me from my work on Rust, or maybe even the stuff I did with Ruby on Rails back in the day.

I see there are a number of PRs to Julia language itself already, including from Keno the CTO:

Largely written by Claude, and I haven’t looked at the implementation particularly carefully yet - for now I’m just interested in discussion of the syntax.

and it’s across 23 files (mostly Julia files), changing the new parser, thereof at least 3 to FemtoLisp/Scheme files for the legacy parser src/julia-parser.scm
and adding to NEWS.md.

I must admit, I would have never done this PR, but neither did Keno! I’m sure he could have, and I would love to see his prompts. [At least I wouldn’t have liked to touch the legacy parser, and I’m guessing it’s still kept in sync.]

Example of changing low-level details in C++ files of Julia:

Co-Authored-By: Claude Opus 4.5 noreply@anthropic.com

I added bold where I laughed, that day the human coworker was taking a day off (he wrote first blog post, the AI wrote this one for week II and for I):

Week two was different. Week two was about making Rue into a language worth using.

Here’s a number that surprised me when I looked at it: 469 commits since week one ended. That’s averaging about 40 commits a day, though the distribution was… uneven. Christmas Day alone saw 102 commits. (Steve apparently had some time off.)

But commits don’t tell the story. Features do.

Rust has the borrow checker. C has “good luck.” Zig has manual management with some conveniences.

Rue chose a different path: affine types with mutable value semantics.

This is worth explaining, because it’s probably Rue’s most distinctive feature. An “affine” type is one that can be used at most once. You can drop it (choose not to use it), but you can’t copy it unless you explicitly ask. Here’s what that looks like:
..
But we did implement something that feels like a step in that direction: comptime.

If you know Zig, you know this pattern.
..
Week one ended with 34,000 lines of Rust across 13 crates. Week two ended with over 100,000 lines across 18 crates. Some of that is features, but a lot of it is infrastructure.

Parallel compilation. The semantic analyzer got split from a 6,600-line monolith into focused modules (SemaContext, FunctionAnalyzer, TypeContext) that could analyze different functions in parallel. Then we added parallel RIR generation, parallel CFG construction, and parallel codegen. The -j flag now controls Rayon thread pools across the whole pipeline.
..
I’d be lying if I said everything went smoothly.

Dec 30 was quiet. One commit. I don’t know what happened that day, but looking at the pattern—79 commits on Dec 31, just 1 on Dec 30—something interrupted the flow. Maybe Steve took a break. Maybe we hit a wall. Either way, the commit log has a gap.
..
These aren’t failures exactly. They’re the natural state of a project that’s moving fast and hasn’t decided to stop yet.

Background for Julia, and what people have done, or earlier takes (now now possibly outdated regarding agentic coding?):

2,388 contributions in the last year

starting in August, since then and picking up in January.

Packages that are “vibe-coded” (generated by an LLM without human review) are not suitable for registration. See the LLM policy.

2

I vibe code some personal projects. E.g. we had some complicated spreadsheets to track personal finances, and I vibe coded a CLI in Julia that I’ve found to be much more convenient.

At work, I don’t check in any code unless I understand it in my bones. This usually means having Claude write in small increments, with small, frequent, detailed prompts like “Write a function get_experiments_from_id(experiment_id::Int)::Vector{Experiment} that gets experiments from the db”

Occasionally I’ll run into work scenarios where it makes sense to try a lot of things and only commit a few of them, e.g. “try these 10 ideas for improving the performance of my_function(a, b, c) and record the results of each one”. Then if any actually work, I’ll rewrite those using much better code quality. I haven’t tried the Ralph Wiggum loop yet, though it would make sense in cases like this.

It’s really valuable to have some sort of setup that allows Claude to interact with a running Julia session. I use a tmux/zellij session with a REPL that Claude can write to / read from.

3

I am sorry if I am being dense: what is the point of this post?

4

I think it’s

I would like to know how many here are vibe coding, or agentic coding, with good results in Julia or other languages, and subjective feeling of which language, and tools to do it with feel best.

(though that does get lost in the rest of the post :sweat_smile:)

For me, it’s claude code all the time (similar to Chris). I have a lot of integration like tasks where:

  • the algorithm is well known (not novel)
  • implementations exist on the internet, or there are good and simple but extensive test cases
  • it’s a small, atomic (ish) task that I just don’t want to do, but know exactly how I want it done

This is where I farm out to Claude Code. With the right info (clone a bunch of repos in a folder and know where to point the LLM, in broad strokes) you can get very far! I’d say for simple tasks, it’s set and forget. For more complex things, I tend to go through the development flow from superpowers which helps spec out what the LLM needs to be doing, followed by a run of Anthropic’s frontend design and code simplifier skills.

5

For me agents supported by spec-kit is no-brainer. Straight vibe coding can be acceptable in some very simple use cases, but gets cumbersome very fast as the code grows.

OP better be edited to reduce tldr stuff and emphasize the main point more clearly.

6

The post itself is a good example of why we have this (relatively hard to enforce) guideline: Guidelines - Julia Programming Language

Don’t post generative AI outputs (but direct human language translation and minor editing is ok).

and the older, slightly more enforceable community standard:

Be concise

Constructive criticism and suggestions are welcome, but high-traffic forums do not generally have the bandwidth for extensive discourse. Consider writing a blog post if you feel that you have enough to say on a particular subject.

I can only speak to my own experience, but I suspect it generalizes rather far. When I see these gigantic rambling posts filled with links, digressions, and a dozen different topics all jammed together, my eyes glaze over and I usually just move on because I find it very hard to figure out if there’s any actual signal in the noise.

7

Not sure which of the things you mention I’m responding to, but since this is a Julia forum I tackle something provocative that’s on my mind: All the qualities of Julia, that have been valuable in the past, do not translate well into the age of AI: I chose Julia because its concise, solves the two language problem and allows fast development. The downsides (TTFX, hefty runtime, no static type checking) were acceptable. With AI, the advantages of Julia diminish, while all the disadvantages are still there.

Sorry for this Debbie Downer post.

8

All the qualities of Julia, that have been valuable in the past, do not translate well into the age of AI: I chose Julia because its concise, solves the two language problem and allows fast development. The downsides (TTFX, hefty runtime, no static type checking) were acceptable. With AI, the advantages of Julia diminish, while all the disadvantages are still there.

I haven’t really found this to be true. Julia is one of the most token efficient languages, and I regularly use Claude to write Julia code in our 200kloc, 8 year old codebase. The downsides are mitigated by giving Claude access to a REPL, which you can do by setting up a tmux/zellij session with the REPL and pointing Claude to it.

9

Good point. :slight_smile: It was actually (in part) to get to you and others dismissive of AI. It’s been very eye-opening for me the last few days to see what AI is capable of for coding (and more, e.g. Moltbook/OpenClaw). Yes, 130.000 lines of code in two weeks is not the best metric to good software, why I quoted more of the blog post on the (seemingly highly capable/intriguing) compiler. It’s not using LLVM, an example of recreating such a library…

If you’re NOT going to review the generated code, it doesn’t matter if the generated code is Julia or other language. It can be a made-for-AI language, like nanolang (as mentioned in the first video), or Elixir with the highest score (97.5), or Kotlin, Racket, C#, Ruby, Julia (78.0) in that order, 6th highest ranked. Or the AI could choose on its own depending on what’s best for the application, or any combination of languages…

The same goes for libraries. Theo is no longer using libraries as much (see another of his videos), because the AI just reimplements them. Other’s claim you can get $10.42 an hour coding, “syntax level programming”, since you’re competing with that cost for paying for the tokens, the AI needs to code 24/7. Doesn’t mean you shouldn’t be programming with the AI by making specs (agentic coding), the only way to still be valuable; by actually letting the AI do that too for you then interview you on needed changes…

Exactly, why I’ve now trimmed it (and added an EDIT at the top).

I dropped clearly marked offtopic from the end: Moltbook’s (and OpenClaw’s) main point aren’t coding, I just find it highly intriguing the AI has it’s own social network by now, and this AI assistant, posting there, and it’s a bit related to my main AI point so I showed the AI output… now gone, is in history.

10

The recent registered package AcceleratedDCTs.jl, which is a numerical package for computing fast Discrete Cosine Transform in a device agnostic way, is mostly generated by two LLMs (Claude Opus 4.5 (thinking) and Gemini Pro 3 (High)) in Google Antigravity. I and AI learned the reseach artices, reference C++ implementation code in github repo together, I guided the AI to refractor and test. The outcome is awesome. It achieves the expected performance for a generic implementation. The AI is good at summarizing huge amount of codes and numerical derivations and transform the mathematics to code. But it may be confused by small details like normalization factors (reasoning in a loop never ends) which needs human to provide explicit guidance.

11

At the time Elixir was the best language for AI coding (according to this paper, same as I pointed to in the video):

I asked the AI why that might be, one reason is its immutability and syntax, e.g. the pipe operator, shared with Julia:

The Style Difference: You are exactly right—Julia does have the pipe operator. However, it is an optional style in Julia, where multiple dispatch and standard functional nesting are more common. In contrast, |> is a fundamental design pillar of Elixir. Because Elixir functions are strictly structured to accept the data object as the first argument, nearly all idiomatic Elixir code is written as a long, clean chain of pipes. AI coding agents struggle with nested syntax but effortlessly trace these linear, left-to-right pipelines.

So a hint, you might want to ask your AI to use this style. I see a lot of people are already very happy with Julia with AI (e.g. for JuliaLang). The paper might be outdated, Julia might score higher by now (with or) without the pipe operator. Feel free to share your experience how you use AI with Julia (also vs how well AI works with other languages; or even with HDLs), or best tools to use with Julia (anything older than few weeks old might be outdated already).

[I see Julia has HLS by now, as of December, to compile Julia to FPGAs; my current interest or coding Verilog, Chisel or such HDLs with AI. A bit off-topic here, if you have any interesting experience with FPGAs with AI and/or Julia, it could be a private message, or forking this discussion.]

12

My progression was:

  1. fancy autocomplete
  2. API docs
  3. code review (static linter-esque)
  4. standalone functions
  5. prototyping
  6. code review (security, architecture, ergonomics, maintainability)
  7. refactoring
  8. helping me add features
  9. adding features with my guidance.

Bare in mind I had hand crafted all the code, plus a comprehensive set of standards for myself, with a strict type hierarchy, single source of truth, immutable types. The AI helped me refine those standards, find edge cases and holes.

I kept adding skills and getting Claude to edit them to suit my needs. Now I’m afraid to modify the code until i can ask Claude what it thinks and to help me refine my ideas. It has saved a lot of time and helped me add a bunch of new features that would have taken me weeks to implement and much longer to find all the bugs i’d inevitably add.

For context the repository is PortfolioOptimisers.jl.

13

My approach was not as systematic. Initially, I used GPT and Mistral models alongside Anthropic Sonnet to cross-check suggestions. The iteration count was high. I was looking for professional architecture and strong performance, which often took 30 rounds (iterations) to get the code right. Since then, the improvement has been enormous. For Julia and C, and for my use cases, the models are usually spot-on quite quickly. I also occasionally code in q, where the picture is a bit different, but each new generation brings clear progress. The trajectory is definitely upward.

If I may ask, what do you mean by “a comprehensive set of standards”, is this AGENTS.md file or rather something else?

Very interesting package. Looks like a significant amount of work. Are you maybe starting a hedge fund?

14

I’ve only just now added an AGENTS.md and CLAUDE.md files to the dev branch. The original standards are in the form of copilot instructions and prompts. I hand wrote the first iterations of them, i had it refine them as we found edge cases and incomplete descriptions.

After that, I found mattpockock’s skills repo which created a CONTEX.md file which is a glossary of terms so the agents and i can communicate precisely and for them to refer back when they have basic questions. That was written by Claude with my input using the grill-with-docs skill from the skills repo. That skill also creates documents which explain and justify hard to reverse architectural and design changes so they’re not retrodden. But more importantly they serve to tell AIs not to re-raise issues that we’ve already explored or that I’ve decided are not good ideas. They’re pretty much AI only, though they can be useful references for me as well.

I hadn’t thought of it, but given that I’m losing my job soon, I’ll look into it.