> Co-Authored-By: Claude Opus 4.5 [noreply@anthropic.com](mailto: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 and Beyond: Building a Language Feature by Feature | Blog | Rue](https://rue-lang.dev/blog/week-two-and-beyond/)**
>
> A systems programming language with memory safety and high-level ergonomics
> 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?):
> [@The use of Claude Code in SciML repos](https://discourse.julialang.org/t/the-use-of-claude-code-in-sciml-repos/131009/8):
>
> Basically, Claude is really not smart at all. There is no extensive algorithm implementation that has come from AI. I know some GSoCers and SciML Small Grants applicants have used AI (many without disclosure) but no wholesale usage has actually worked. And not even for me either. Claude can only solve simple problems that a first year undergrad can do, it can’t do anything more, it’s pretty bad. For people who can use it for more, it’s probably some standard Javascript or Android app that is the 20,000th version of the same thing, and yes it probably is copying code. But by definition most of what we have to do in SciML, especially these days, is a bit more novel on the algorithmic side and so Claude is really bad at trying to get anything right.
> **[A Guide to Gen AI / LLM Vibecoding for Expert Programmers - Stochastic Lifestyle](https://www.stochasticlifestyle.com/a-guide-to-gen-ai-llm-vibecoding-for-expert-programmers/)**
>
> I get it, you’re too good to vibe code. You’re a senior developer who has been doing this for 20 years and knows the system like the back of your hand. Or maybe you’re the star individual contributor who is the only person who can ever figure out how...
> **[ChrisRackauckas-Claude - Overview](https://github.com/ChrisRackauckas-claude)**
>
> Beep Boop this is the ChrisRackauckas robot for SciML development - ChrisRackauckas-Claude
> ## 2,388 contributions in the last year
starting in August, since then and picking up in January.
> Packages that are [“vibe-coded”](https://simonwillison.net/2025/Mar/19/vibe-coding/) (generated by an LLM **without human review** ) are not suitable for registration. See the [LLM policy](#is-there-any-policy-regarding-the-use-of-llms-in-registered-packages).
---
### Author:  [@Satvik](https://discourse.julialang.org/u/Satvik)
#### Post date: [February 1, 2026, 7:54pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/2 "2026-02-01T19:54:54Z")
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.
---
### Author:  [@PetrKryslUCSD](https://discourse.julialang.org/u/PetrKryslUCSD)
#### Post date: [February 1, 2026, 9:38pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/3 "2026-02-01T21:38:25Z")
I am sorry if I am being dense: what is the _point_ of this post?
---
### Author:  [@asinghvi17](https://discourse.julialang.org/u/asinghvi17)
#### Post date: [February 1, 2026, 10:35pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/4 "2026-02-01T22:35:35Z")
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 😅)
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](https://github.com/obra/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.
---
### Author:  [@yvikhlya](https://discourse.julialang.org/u/yvikhlya)
#### Post date: [February 2, 2026, 8:59am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/5 "2026-02-02T08:59:34Z")
For me agents supported by [spec-kit](https://github.com/github/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.
---
### Author:  [@Mason](https://discourse.julialang.org/u/Mason)
#### Post date: [February 2, 2026, 2:55pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/6 "2026-02-02T14:55:29Z")
> [@PetrKryslUCSD](#):
>
> I am sorry if I am being dense: what is the _point_ of this post?
The post itself is a good example of why we have this (relatively hard to enforce) guideline: [Guidelines - Julia Programming Language](https://discourse.julialang.org/faq#keep-tidy:)
> Don’t post generative AI outputs (but _direct human language translation_ and minor editing is ok).
and the older, slightly more enforceable [community standard](https://julialang.org/community/standards/#be_concise):
> ### 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.
---
### Author:  [@laborg](https://discourse.julialang.org/u/laborg)
#### Post date: [February 2, 2026, 5:53pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/7 "2026-02-02T17:53:37Z")
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.
---
### Author:  [@Satvik](https://discourse.julialang.org/u/Satvik)
#### Post date: [February 2, 2026, 7:57pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/8 "2026-02-02T19:57:06Z")
> 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.
---
### Author:  [@Palli](https://discourse.julialang.org/u/Palli)
#### Post date: [February 2, 2026, 8:07pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/9 "2026-02-02T20:07:07Z")
> [@PetrKryslUCSD](#):
>
> what is the _point_ of this post?
Good point. 🙂 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…
> **[GitHub - jordanhubbard/nanolang: A tiny experimental language designed to be...](https://github.com/jordanhubbard/nanolang)**
>
> A tiny experimental language designed to be targeted by coding LLMs
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…
> [@asinghvi17](#):
>
> 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 😅)
Exactly, why I’ve now trimmed it (and added an EDIT at the top).
> [@Mason](#):
>
> The post itself is a good example of why we have this (relatively hard to enforce) guideline: [Guidelines - Julia Programming Language](https://discourse.julialang.org/faq#keep-tidy:)
>
> > Don’t post generative AI outputs
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.
---
### Author:  [@liuyxpp](https://discourse.julialang.org/u/liuyxpp)
#### Post date: [February 3, 2026, 2:00am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/10 "2026-02-03T02:00:31Z")
The recent registered package [AcceleratedDCTs.jl](https://github.com/liuyxpp/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.
---
### Author:  [@Palli](https://discourse.julialang.org/u/Palli)
#### Post date: [August 3, 2026, 5:01pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/11 "2026-08-03T17:01:28Z")
At the time Elixir was the best language for AI coding (according to this paper, same as I pointed to in the video):
> **[Why Elixir is the best language for AI - Dashbit Blog](https://dashbit.co/blog/why-elixir-best-language-for-ai)**
>
> A recent study by Tencent showed that Elixir had the highest completion rate across models when compared among 20 different programming languages. In this article, we explore the reasons why that may be the case and how that extrapolates to coding...
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.]
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [August 3, 2026, 6:53pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/12 "2026-08-03T18:53:59Z")
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.
---
### Author:  [@j\_u](https://discourse.julialang.org/u/j_u)
#### Post date: [August 4, 2026, 10:34am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/13 "2026-08-04T10:34:58Z")
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?
> [@dcelisgarza](#):
>
> For context the repository is [PortfolioOptimisers.jl](https://juliaregistries.github.io/General/packages/redirect_to_repo/PortfolioOptimisers).
Very interesting package. Looks like a significant amount of work. Are you maybe starting a hedge fund?
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [August 4, 2026, 11:24am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/14 "2026-08-04T11:24:29Z")
> [@j\_u](#):
>
> If I may ask, what do you mean by “a comprehensive set of standards”, is this AGENTS.md file or rather something else?
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](https://github.com/dcelisgarza/PortfolioOptimisers.jl/tree/main/.github/instructions) and [prompts](https://github.com/dcelisgarza/PortfolioOptimisers.jl/tree/main/.github/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](https://github.com/mattpocock/skills) skills repo which created a [CONTEX.md](https://github.com/dcelisgarza/PortfolioOptimisers.jl/blob/main/CONTEXT.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](https://github.com/dcelisgarza/PortfolioOptimisers.jl/tree/main/docs/adr) 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.
> [@j\_u](#):
>
> Very interesting package. Looks like a significant amount of work. Are you maybe starting a hedge fund?
I hadn’t thought of it, but given that I’m losing my job soon, I’ll look into it.
---
### Author:  [@j\_u](https://discourse.julialang.org/u/j_u)
#### Post date: [August 18, 2026, 6:36pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/15 "2026-08-18T18:36:42Z")
@dcelisgarza If I may ask, I’m wondering, what’s the shortest timeframe your package `PortfolioOptimisers.jl` is able to sustainably operate on a permanent basis, do you maybe have any estimates?
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [August 18, 2026, 11:57pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/16 "2026-08-18T23:57:21Z")
It’s very usable now, it’s pre `v1` so i’m breaking on every `v0.x` release. Have a look at the examples to see how much depth there is.
I’d love to get users so i can get some feedback, particularly when it comes to UX as that is where i haven’t focused. Any suggestions and contributions are very much welcome.
I have a PR that’s gonna make some more breaking changes but also fix up a bunch of things and add a ton of functionality. That will be landing in the next week or so.
But unless you use the more esoteric functionality you should be safe to start using it.
---
### Author:  [@j\_u](https://discourse.julialang.org/u/j_u)
#### Post date: [August 19, 2026, 9:15am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/17 "2026-08-19T09:15:13Z")
I took a look, of course. It seems like the performance depends on JuMP, which makes it hard for me to estimate. Particularly in this context. I’ve always viewed JuMP as something a bit too advanced for my needs. I’ve never had a practical use for such a powerful tool in my daily life.
As for the UX, I approach it differently. I wrote about this a bit in that long backtesting thread. I focus much less on Julia specifically, as I have a different philosophy in this area and see Julia as part of a broader ecosystem of tools.
I wouldn’t say esoteric. I was just looking into shorter intervals. Anyway, thanks for this additional info.
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [August 19, 2026, 9:50am UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/18 "2026-08-19T09:50:50Z")
Yeah it’s not really a tool for high frequency trading. However, i’m planning an algorithmic trading package that uses PortfolioOptimisers.jl as its brains. You’re of course welcome to try it out for your needs. I’ve tried to get free tier LLMs to whip up small scripts by pointing them to the examples. It might be worth a shot.
If you do, I would recommend the naive or hierachical optimisers though. InverseVolatility, SchurComplementary, HierarchicalEqualRiskContribution. Probably with the cheaper risk functions and if using some sort of covariance estimator, i’d use a robust covariance estimator like Gerber, SmythBroby or GerberIQ, or the normal covariance but using a shrinkage estimator.
---
### Author:  [@DoktorMike](https://discourse.julialang.org/u/DoktorMike)
#### Post date: [September 9, 2026, 12:35pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/19 "2026-09-09T12:35:09Z")
I would suggest you make JuMP an optional dependency (you can hotload it for when you really need it). It’s quite heavy and I often feel that it’s not warranted for most optimization problems in the wild. I’m biased of course since I rarely care about perfect mathematical optima (they don’t exist in my field of work).
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [September 9, 2026, 1:26pm UTC](https://discourse.julialang.org/t/vibe-coding-vs-agentic-coding-ralph-wiggum-loop/135389/20 "2026-09-09T13:26:37Z")
I’ve thought about partitioning things into extensions. There’s three optimiser families, one needs Clustering.jl, another JuMP.jl, the other only Statistics.jl and StatsBase.jl. However, the break isn’t clean. I’d have to change things around substantially, but i’m thinking about it.