thanks!
2,939 karma · joined March 8, 2026
No promises on code quality, of course. Cheap things are cheap for a reason, right?
It's not work-related — feel free to reach out just because you want to get closer
My writing is mostly just tracking various internet posts to trace history. How do you create interesting posts based on personal experience like this?
Naur argued that when a team disbands, the program dies. But in an era where the primary maintainer is no longer human, but an AI agent, how should we approach this?
My take is that we will lean heavily on concepts like Algebraic Data Types (ADTs) and state machines—making state definitions something humans can readily track through explicit specifications—while modularizing boundaries so that humans only need to retain the interfaces.
In other words, rather than keeping low-level implementation details in our heads, systems will be structured around high-level interfaces, data flows, core capabilities, and first-class functions.
Of course, the prevailing assumption today is still that humans must grasp the underlying implementation to work effectively. There are trade-offs to both models, and the optimal balance will naturally vary across different workflows.
Ultimately, the core issue is this: when something goes wrong within the AI's internal implementation, will we actually be able to steer it? And as you know, even ADTs must eventually change when business requirements shift. I haven't thought deeply about how to handle that yet, either.
It's an open question that neither experienced programmers like yourself nor less experienced ones like me have the definitive answer to. Software is heavily dependent on highly personal contexts. My answers and experiences won't neatly apply to your context, and vice versa.
My guess is that we might eventually need an entirely new programming language. What would that language look like? I have no idea. IDEs might also shift away from traditional text blocks toward a UI-based, flowchart-like approach. I imagine a system somewhat like n8n, where we can visualize and track the workflows and code blocks generated by the AI.
I recently did a few "vibe coding" projects with AI. It churned out 50,000 to 60,000 lines of code in an instant, and I couldn't keep up. To cope, I built a tool to visualize and track the code's dependencies. It worked out much better than I expected.
The caveat, of course, is that with tools like Unreal Blueprints or n8n, the visual dependency graph eventually explodes as the program grows, turning the UI itself into a bottleneck. Perhaps the solution will be that programs up to a certain size are abstracted into single nodes, which can then be clicked to expand and reveal the underlying implementation details.
However, AI works differently from humans in that much more of its working context has to be made explicit. Because of that, there may be some fundamentally different way for AI to maintain or reconstruct a program’s overall model.
And it's really amazing. I wish I could think like that, and it's impressive how deeply you immerse yourself in it.
In Korea, people call the AI writing style "쇠맛 the taste of metal.(or metallic taste)" They say it tastes like a machine.
When Koreans generally define the metal taste, they usually put it something like this: "The plot is terrible, but the sentences are really excellent and refined."
Generally, unless you're using a fine-tuned local model, sentences with that metal taste are considered refined. So there's this irony where people say writing not done by AI lacks refinement.
In fact, even very famous Korean authors have been caught using AI, but people didn't really notice—they just felt the prose had become very elegant.
Anyway, I'm rambling, but the thing is, AI sentences were basically "learned and erudite" by default. When I entered grad school in Korea, I was taught where to use hyphens, told these were "things you need to learn when writing papers," and learned language techniques while being taught how to write papers—and AI uses those techniques really well. So it's ironic.
It's just a shame that in order to avoid writing with that metal taste, you have to avoid the very vocabulary that used to be recommended.
The performance changes between models are almost static. Recently, GPT has shifted almost entirely toward token efficiency.
Astra is good at making 3D assets, but realistically its coding was not as good as GPT 5.6 Sol.
Have we reached a point where getting better at one thing means starting to get worse at another?
This announcement is the worst one yet.
Nerfing existing usage A more expensive top-tier plan Showing off how slow Dots is right in the demo video And GPT Space—are they telling us to use it instead of Notion or what...
Overall, throughout the entire announcement, everything OpenAI wants me to look forward to just leaves me, as a developer, disappointed.
A lot of people complain about OOP, but it's a paradigm very well suited for rapid development.
Sol should basically be compared to Opus, but 6 Sol has lower performance than 5.6 Sol.
On top of that, the usage allowance has dropped way too much. And this is on the Pro plan...
But they gathered employees who had been working as PMs at that company and developed a product using only prompts. It turned into a project where fixing one bug created ten more, and nobody could understand why the bugs were being generated.
Management framed it as "the beginning of in-house development and the end of outsourcing," but the employees who actually contact me about work say things are going badly.
In fact, there have been several incidents in Korea related to vibe coding.
So I don't think coding is a solved problem.
Even when I code with AI, it's not really my code, so fixing bugs is hard... I don't think coding is a solved problem.
I've also heard it happens in some games as well, but either way, the one I can say for certain is crypto.
It's a nautilus. If I remember correctly, the original idea came from `gyre -> spiral`, so I attached meaning to the spiral shape of its shell.
The reason gyre ended up in the name was that I had this idea that a world, or perhaps a program, keeps curling inward through layers.
At the time, I was studying state machines. Once you define a state machine, you also define its state space: how far that space can expand, what states are possible, and where its boundaries are.
But the more I programmed, the more I felt that software kept repeating the same structure inside itself. You establish an outer boundary, then inside that boundary you create another state space and another boundary, and then another one inside that.
So I started wondering whether a program is something that begins by defining an outer frame and then keeps spiraling inward.
When I first started designing the language, one of my biggest inspirations was D&D.
That's partly why I chose words like `ability` instead of `interface` or `trait`. The idea was closer to, "this subject must have this ability," rather than "this type implements this interface."
I like fantasy games, and most RPGs tend to describe their worlds using fairly similar concepts and vocabulary.
Around the same time, I was reading material about Simula 67. What interested me was the old question behind Simula: how do you represent a world using a programming language?
When humans describe worlds, we probably do it most extensively in fiction and games. So I thought: why not build a programming language using words humans already use when describing a world?
I started collecting those kinds of words and turning them into language concepts.
Originally it was just a small language with a C backend. Then AI arrived, I became more ambitious, and the project gradually grew much larger than I initially intended.
So there is a `World`, and inside the world there are `Zone`s. At first I considered using `Realm`, partly because of D&D, but in Korea people tend to use the word "zone" much more naturally for this kind of spatial division, so I ended up with `Zone`.
The project has grown quite a lot since then.
It's still incomplete. The source of truth for the semantics is not fully closed yet, and there are many rough edges, although I've confirmed that at least some of the basic ideas actually work.
I'm also trying to make it a memory-safe systems language without relying on a GC.
One of the inspirations was Vale, an experimental language that explored generational references. I took that idea and tried to expand it into something broader: in Pergyra, I think of a `Slot` as a resource identity, and the compiler tracks transitions in the state of that resource. (Vale itself seems to have moved away from that approach in its successor, Valen.)
The compiler pipeline is roughly:
`HIR -> DIR -> RIR -> MIR -> backend`
At the RIR level, memory accesses are interpreted as resource-state transitions, and resource operations are normalized there.
This does mean that Pergyra can carry more runtime machinery than some other systems languages when those checks cannot be eliminated. On the other hand, the same resource identity model has been useful for reasoning about parallel access and concurrency.
I still don't think I can honestly claim that the language is completely memory-safe yet, and I'm not even sure whether this approach will ultimately turn out to be the right one.
But as the design evolved, I noticed the same spiral structure appearing again:
`World -> Zone -> ... -> Slot`
The layers keep curling inward.
That's why I chose the nautilus.
There's another meaning I like as well: the nautilus is often described as a "living fossil," and in a way I'm taking an old question from Simula — how should a programming language represent a world? — and trying to revisit it from a different direction.
I don't really expect the language to become successful. I'm not even sure I've written the compiler particularly well. I'm currently using it in a few small projects to see whether the ideas survive contact with real software, but I don't know how far it will go.
Thank you for taking an interest in it.
My personal goal, though, is much simpler: I want to make a game in my own language.
I think that part is probably achievable within the next two years.
Personally, I think new languages will end up taking a form similar to the grammar of existing languages, but with different semantics. That's because when I tried a completely new grammar, the AI couldn't generate code well, so I ended up spending time bringing in TypeScript's grammar and converting it into my language's mental model.
My language isn't anywhere near as sophisticated as the languages the developers here boast about creating (it's actually lower), but these days it at least runs, even if it's full of bugs. So sometimes I think that many people like me will develop languages, and that programming might end up becoming fragmented.
So it's true that those in power are harming innocent people in order to maintain their power, but it's also true that Japanese people believe they are being harmed by foreign immigrants.
And some of it is actually true. Of course, conversely, there's also the problem of many Japanese companies hiring Southeast Asian workers at low wages and mistreating them.
But whether it's me as a Korean or Japan, both tend to have a certain authoritarian mindset instilled based on "ethnic" identity. So one aspect of this policy is "we only welcome rich foreigners who spend money and leave," and the media responds accordingly.
Strictly speaking, if you look at these policies strengthening restrictions on foreigners from a third-country perspective, you can see them from the angle of far-rightization. That is, sanctions against outsiders for the sake of internal cohesion[1]. But considering the severe aging population in Japanese industry right now, it's effectively cutting off one's own nose to spite one's face.
However, East Asians receive a somewhat different education from you, so that's how it is.
The real cause is the failure of Abenomics and the resulting weak yen, which benefits financial companies and exports but sacrifices the Japanese people—the incompetence of the regime is the problem. But because it's hard to grasp all of that complex background, people want to attack something else that's near them.
And also, because the morality of some underdeveloped countries (I know it's an example...) differs from that of developed countries, friction often occurs. Just as the sense of time differs between agricultural regions and cities, for instance.
[1]https://csrda.iss.u-tokyo.ac.jp/socialresearch/pr/26PressRel...
Similarly, I did well in interviews where I could use the internet, but I didn't do well in interviews where I couldn't use the internet.
Everyone has a testing format they're good at. I'm curious about how this kind of thing is evaluated, and whether there are any papers related to this.