ontouchstart

> You find a blog you like, and use that as a thread of knowledge. You join a community and talk with someone and share resources together. Join a small group chat and post with those people. Your knowledge sharing comes from people you share interests with.

It is hard to find communities where people are not evangelical and soon you become an evangelist.

I am using LLMs to build my own graph of thoughts and try my best to follow them with critical eyes. Do not want to be influenced by or influence others.

Analysis and synthesis are two sides of human intelligence. Current form of generative artificial intelligence is very powerful in synthesizing information and producing artifacts, human will lose this battle.

Understanding is about analyzing and we still have some tools to help us, such as type checking, testing, etc. To some extent this can be automated but needs to be maintained automatically to match the flood of synthetic artifacts.

“Synthetic analysis” is an oxymoron and could lead to hallucinations and irrelevance.

Ideas are seeds. Seeds can be cheap or expensive, but perhaps what we want to talk about is not the _cost_ of ideas but the _value_ of ideas.

The correlation between cost and value can be very complicated, especially in the chaotic world (or chaotic situation).

42!

https://live.lean-lang.org/#codez=CYUwZgBAhgdgzgdxAJwgLgLwQC...

(I am fscking physics major! ;-)

> I dug through the chain-of-thought publication and did actually find (a few of) them. If people working on these LLMs are reading, it's very important to me that these are contained in the actual model output.

This is a very important point, especially when the output is from a non-deterministic random walk with some unknown probability distribution.

This would be a cool template project to learn C++ without the pollution of LLM slop.

Conclusion of the article (Wisdom from 1982):

> There is an old adage (e.g., Zen) to the effect that we become what we perceive. In computer terms, our (human) outputs become identified with our inputs. Computer technology is exceedingly habit forming, and our civilization seems to be becoming more computer-like, in the name of "progress". Many people tend to identify with their computers, while others become more computer-dependent, willingly or unwillingly. In addition, the so-called "factory experience" has an antihuman element to it. Although it could indeed help to reduce repetitiveness, it must also allow a suitable role for creativity. (In the spirit of this paper we note that unbridled attempts at creativity can often be detrimental, resulting in obfuscational terminology that masks an absence of novelty, or the reinvention of suboptimal or intermediate steps that have previously been discarded by others for subtle reasons not perceived by the "reinventor".) Thus, it is incumbent on system designers and system development managers to understand the negative effects of the use of computers, and to attempt to minimize those negative effects. In this way, it should be possible to increase incentives, challenges, and satisfaction, to reduce boredom, burnout, and laziness, and generally to increase the effectiveness of computer developers and users.

By "embracing" I mean embracing the coming storm and survive it, facing the challenge and admit it is not magically going away.

> Although there is an element of apparent sloppiness in many creative people, discipline is also required. (Note that time-sharing has been condemned by some as encouraging sloppiness, as opposed to batch processing [where sloppiness can be exceedingly costly in time and computing resources]. Perhaps time-sharing could actually encourage creativity, although there is the countering argument that computers intrinsically stifle creativity.) Similarly, diversity of experience also appears to be extremely important (e.g., [Sheppard]); the perspective afforded by familiarity with a variety of systems, subsystems, programming languages, and methodologies provides extremely valuable insights, especially where there is wide diversity (e.g., among TOPS-20, Multics, UNIX, and OS/370; SCRIBE, TEX, PUB and ROFF; Pascal-based languages and LISP; a formal methodology/specification language and conventional design).

I will think “Agentic Engineering” is the “time-sharing” of our time. Embrace it.

Bookmark this link for future reference, it is very relevant in the era of “agentic engineering”

https://dl.acm.org/doi/pdf/10.1145/1005937.1005938

Someone wrote a web server in assembly the other day: https://news.ycombinator.com/item?id=48080587

It is very inspiring.

> Even more importantly, what happens to teamwork? If we are all a BBM now—or rather, if we all have personal armies of BBMs, permanently locked in a manic state, springloaded at all hours to generate things for us-and-only-us—how do we work together? How do cocoons communicate, interoperate? What does a team of ai solipsists look like? It sounds oxymoronic.

One example of teamwork is how the programmers and researchers worked together to build the UNIX SYSTEM (https://www.cs.dartmouth.edu/~doug/reader.pdf). It is not a product but an environment optimized for building tools and solving practical problems with tools written in C (while BBMs were busy with Lisp in Boston .;-)

C++ is a totally different story and you need an IDE for that.

I couldn’t help but notice the similarities between human aging and “filling up” the context window in Agentic AI: the “chain of thoughts” getting so heavy that nothing new can be created.

On the other hand, there was lot of disruptive work did survive, or we can call them “hallucinations”.

Hindsight is 20/20.

The reason I wrote that compact makefile is that I am at the beginning of a long journey to study the coding style of ngnk (https://news.ycombinator.com/user?id=ngnk).

I can see the potential of doing some implementation of APL/J/K at levels even lower than C, like how those guys did APL\360 using assembly language. It is going to be super fun in the era of everyone using LLM to pump out verbose Python/TS/Rust code with context windows bigger than the whole operating system.

What I love most about your project is the super clean Makefile (https://github.com/imtomt/ymawky/blob/main/Makefile). It is a great template to jump start an ARM64 assembly project.

I made a self documented (all the related links are in the file) single makefile (https://gist.github.com/ontouchstart/d3ad8e4d0adf63532303a90...) so that anyone can build ymawky from scratch and dig deeper by tinkering.

Some people must be working on training some models exclusively on high quality OSS code base like curl and SQLite without the noise of low quality training data.

I would do that with 100% local models from scratch.

Michael Rabin, 1976 ACM Turing Award Recipient

https://youtu.be/L3FZzGU3n14

100%.

UX is where the money is, it is in the wrapper, not the core.

Unfortunately, the core is the most valuable and labor intensive part of it.

With agentic coding, the gap between solid core and shitty wrapper is going to be wider and wider.

Thanks. This is so hilarious ;-)

https://mariozechner.at/nothanks.html

I didn't see it on mobile. So it only happened to desktop browser.

I only found out via pi myself:

> pi --continue -p "Check the link and see if there is a banner to turn back users from HN community"

Goodmythical’s comment was *accurate at the time it was written* – the link did trigger the “no‑thanks” page when it was opened from Hacker News. The “banner” is not a visual element that lives on the main article page; it is the content of the separate *`/nothanks.html`* file that the site redirects to.

When the redirect was in place, the user experience was:

1. User clicks the link while still on `news.ycombinator.com`. 2. The script in `components.js` sees the referrer and redirects the browser to `/nothanks.html`. 3. The `/nothanks.html` page displays the single line “hi orange site user …” – this is what Goodmythical described as the banner.

If you now visit the same link directly (e.g., from a bookmark or a search engine) the redirect is bypassed and you see the normal article, so you won’t see that page at all.

I forked pi-mono to freeze it.

Here is a session of pi analyzing coding-agent package itself.

https://ontouchstart.github.io/.pi/agent/sessions/--pi-mono-...

It was created via a non-interactive CLI command in a docker container connected to a local llama.cpp server with a very limited model. $0 token cost.

My point is pi-coding-agent [1] is a very well designed and implemented open source project that we all can learn from as software engineers. His blog post about his decision making [2] is also very well written.

I should've given original links instead of noisy HN threads.

[1] https://github.com/badlogic/pi-mono/blob/main/packages/codin...

[2] https://mariozechner.at/posts/2025-11-30-pi-coding-agent/

pi-conding-agent itself is not a product yet and it won't have much value to end users other than those using the products built on top of it.

Some technical background:

https://news.ycombinator.com/item?id=46844822

I found out last night via pi.dev. And the new repo of pi didn’t exist yet.

I have been working with pi-mono locally for a few months now. Great code base to study. Much higher quality than CC. (I have posted a gist analysis before.)

Will keep an eye on the work of these talented engineers and entrepreneurs. Good luck guys!

Vibe coding is like building castles in a sandbox, it is fun but nobody would live in them.

Once you have learned enough from playing with sand castles, you can start over to build real castles with real bricks (and steel if you want to build skyscraper). Then it is your responsibility to make sure that they would not collapse when people move it.

AI “workflows” share the same addictive characteristics of web surfing online virtual media, which can be counter productive. In this regard, we do need some serious learning at all the levels in the workplace. Otherwise we will become addicted to the slot machines.

Addiction is a much harder problem than distraction.

https://gistpreview.github.io/?30a4e491eb2df7523ecc120b86feb... (pi)

https://gist.github.com/ontouchstart/d7e3b7ec6e568164edfd482... (cc)

M5 (24G)

I’m using pi and cc locally in a docker container connected to a local llama.cpp so the whole agentic loop is 100% offline.

I had used pi and cc to analyze the unpacked cc to compare their design, architecture and implementation.

I guess your site was also coded with pi and it is very impressive. Wonderful if you can do a visualization for pi vs cc as well. My local models might not be powerful enough.

Thanks for the hard work!