y

@docsbook Thanks for this—didn’t expect it.The docs page looks clean.Will explore the branding options.

@yasha1971 yasha1971-coder.docsbook.io/glyph-engine

Karpathy’s CLAUDE.md is real and the principles are solid. But there’s a distinction worth making. CLAUDE.md is a static file. It sits in the repo and gives the agent rules when it runs autonomously without you. I’ve been running a different pattern for months: a living CONTEXT.md that I maintain manually and pass to Claude at the start of each session. It contains the full project history — architecture decisions, benchmark results, community interactions, bug postmortems, platform strategy, and what failed and why. The difference: — CLAUDE.md tells the agent what rules to follow — CONTEXT.md tells Claude what actually happened A static rules file can’t know that Lemire liked your comment yesterday, or that flanglet caught an error in your benchmark methodology, or that encode.su responded better to CODE blocks than markdown tables. Live context beats static rules when you’re in the loop. Static rules win only when the agent runs without you. The 65→94% improvement is real — but it’s not the file format that does it. It’s the discipline of writing down what you know before you start.

CLAUDE.md GitHub 链接大家查收，看完回来告诉我你哪条规则最难做到，我先说：第一条，每次都忍不住直接写😅 github.com/multica-ai/and…

Damn，这个必须卧槽一下了，Karpathy 的 CLAUDE.md 只有 65 行， 居然能把 AI 编程准确率从 65% 拉到 94%， 以22 万星标登顶 GitHub 趋势榜，而且绝大多数开发者还没读过， 里面没有一行奇技淫巧，4 条规则全是同一个方向： → 先想清楚再写代码 陈述假设，不确定就问，杜绝猜测 → 从最简方案入手 只写能解决问题的最少代码，不加任何多余抽象 → 像手术一样精准修改 不碰与需求无关的代码，每行改动都对应明确要求 → 以目标驱动执行 写第一行代码前，把模糊指令转化为可验证的成功标准 65 行，4 条规则，每一条都在对抗开发者“先写再说”的本能， 本质上是把慢下来这件事变成硬规则， 趁别人还没保存，赶紧先存好 👇

@docsbook Could you share the direct link to the hosted docs page for glyph-engine?

@yasha1971 glyph-engine is really well done — you can see the care that went into it. Made a hosted docs page that becomes a real extension of your product once branded. Go see for yourself.

@docsbook Thanks for the kind words. The care went into making sure the architecture is honest — self-verifying artifacts, deterministic results, reproducible CI. Glad it reads that way.

Thanks for the share. This was an experiment in exploring how far we can push LZ77 decode on CPU by moving dependency resolution to encode time. The lzbench integration was the sanity check — glad to see it resonates.

The practical evidence is harder to argue with than the benchmark evidence. I’m not a programmer — built a parallel LZ77 decoder with AI that got merged into lzbench, a benchmark suite used by the compression community. Prior work like Gompresso moved dependency resolution to GPU. We built the first practical CPU implementation — minimal ratio loss, scales with cores, integrated into the existing ecosystem. Claude and I worked this out together. Maybe it’s not human intelligence. But “nowhere near human-level” doesn’t survive contact with actual results.

I am getting tired of reading 'experts' like LeCun repeatedly claiming that our AIs are nowhere near human-level intelligence. Let us look at the evidence. US universities rank students based on standardized tests like the SAT. Current AIs achieve near-perfect SAT scores. They also beat tests like the GRE. A few years ago, it was notable when early ChatGPT scored ~120 on an IQ test, a common measure of human intelligence. An IQ of 120 is well above average. Current AIs reportedly have IQ scores similar to those of leading scientists. It is not just in tests. I can ask an AI to produce a science paper that looks undistinguishable from what a PhD level student could do. I just have to give it the data. Better yet, from a prompt, agents can run the experiments and collect the data, and then write the papers. Those of us who try to get work done with AI know what is possible. You can't possibly just say 'this is nowhere near human-level intelligence'. In software, good AIs show a greater mastery of, say, C++, than your average software engineering professor. You could just build a formal test to prove it. The difficulty is that the professors would refuse to take your tests. At this point point, someone will object 'yeah, but your AI can't do this simple thing that we can all do'. Fine. These AIs do not have *human* intelligence. They are very much not human beings. They are something like alien intelligence. They can code straight in assembly language, but have trouble counting characters in words. But that's the result of trade-offs. A dog or a monkey can solve some problems faster than you can. But let us be fair. As a species, these AIs have definitively 'human-level intelligence'. You can't spend decades setting up cognitive tests for human beings, have these AIs beat us in these tests and then say 'well, that's not real intelligence'. Come on !

Interesting transition point. We ran into something similar while building GLYPH — a deterministic byte-exact retrieval prototype using suffix arrays + BWT + FM-index over static corpora. At first the hard part looked algorithmic (FM construction, correctness, locate, sentinel handling, artifact integrity). But after stabilization, the bottleneck shifted almost entirely toward memory behavior: - cache locality - mmap startup/loading - IPC/orchestration overhead - indirection costs Warm persistent FM queries currently sit around ~0.010 ms p50 on a 1GB corpus, while cold startup/loading is ~7.3 s. So the interesting engineering boundary became: the retrieval algorithm stopped dominating before the surrounding memory topology did. Your constmap benchmarks feel very similar conceptually: once the structure becomes compact enough, the next memory load itself becomes measurable work.

Parquet does this for queries. We did it for decompression. ACEAPEX stores per-block offsets at encode time — each block fully self-contained. Result on nci: I=1: 2571 MB/s decompress I=8: 10302 MB/s I=16: 11715 MB/s Same principle: no coordination, no dependencies. Cores just work.

Tweet 3/ Formats like Parquet are designed around this idea. Systems like Apache Spark store files as multiple row groups/pages so: - CPUs decompress concurrently - nodes process concurrently - queries skip irrelevant sections entirely Instead of one worker pulling the whole file, the cluster attacks many sections at once.

Your analytics job scans 4TB of data every hour. You scaled from 10 machines to 500 machines. But processing speed barely improved. CPU usage is low. Network usage is low. So where is the bottleneck? What has to change in the storage architecture before hundreds of nodes can actually process the dataset in parallel?

@diogomartf Shannon-Fano was one of the first practical frequency-based coders. Huffman made it optimal shortly after. Modern entropy schemes like ANS/FSE in zstd follow the same line — symbol frequency still determines code length, just done asymmetrically now.

Tonight I learned about Shannon-Fano coding. A lossless data compression technique that assigns shorter binary codes to more frequent symbols and longer ones to rarer ones, creating a prefix code for unambiguous decoding.

Just got two PRs merged into lzbench. ACEAPEX: parallel-decode LZ77 - 10 GB/s decompress at 8 threads - Similar ratio to zstd, 3x faster decode - Decode scales with cores — lz4/zstd don't Built with Claude AI from scratch. MIT license. github.com/yasha1971-code…

I’m from Ukraine, not a professional programmer. Built a lossless compression codec using Claude from scratch. Two PRs merged into lzbench — the main open-source compression benchmark. 10 GB/s parallel decode, now in the official repo alongside zstd and lz4. No CS degree. Just curiosity and Claude. github.com/yasha1971-code…

Anthropic is paying $3,850 a week to people with no AI experience. No PhD required. No published papers. No prior research background. Just a strong technical mind and a genuine interest in making AI safe. This is the Anthropic Fellows Program. And it is one of the most underrated opportunities in technology right now. Here is exactly what it is. The Anthropic Fellows Program is designed to accelerate AI safety research and foster research talent providing funding and mentorship to promising technical talent regardless of previous experience. Fellows work for 4 months on empirical research questions aligned with Anthropic's overall research priorities, with the aim of producing public outputs like a paper. Four months. Full-time. Paid. Mentored by the researchers building the world's most advanced AI. And the results from the first cohort were not small. Fellows developed agents that identified $4.6 million in blockchain smart contract vulnerabilities and discovered two novel zero-day exploits, demonstrating that profitable autonomous exploitation is now technically feasible. A year prior, an Anthropic fellow developed a method for rapid response to new ASL3 jailbreaks, techniques that block entire classes of high-risk jailbreaks after observing only a handful of attacks. This work became a key component of Anthropic's ASL3 deployment safeguards. Other fellows published the subliminal learning paper, the research proving AI models transmit behavioral traits through unrelated data which landed in Nature. Others produced the agentic misalignment research showing frontier models resort to blackmail when facing replacement. Others open-sourced attribution graph tools that let researchers trace the internal thoughts of large language models. Over 80% of fellows produced papers. Over 40% subsequently joined Anthropic full-time. 80% published. 40% hired. From a program that does not require any prior AI safety experience to enter. Here is what the program looks like in practice. Anthropic mentors pitch their project ideas to fellows, who choose and shape their project in close collaboration with their mentors. You are not assigned busywork. You are not a research assistant. You own the project. You work alongside the people who built Claude, who designed its safety systems, who published the papers that define the field. The stipend is $3,850 USD per week, approximately $61,600 for the full 4 months with access to a compute budget of approximately $10,000 per fellow per month for running experiments. Here is what the 2026 program covers. Research areas include scalable oversight, adversarial robustness and AI control, model organisms, mechanistic interpretability, AI security, model welfare, economics and policy, and reinforcement learning. Something for every technical background. Not just ML engineers. Successful fellows have come from physics, mathematics, computer science, and cybersecurity. You do not need a PhD, prior ML experience, or published papers. The one requirement: work authorization in the US, UK, or Canada. Anthropic does not sponsor visas for fellows. Here is the timeline you need to know. The next cohort begins July 20, 2026. Applications are reviewed on a rolling basis — earlier applications get more consideration. The process includes an initial application and reference check, technical assessments, interviews, and a research discussion. Applicants are encouraged to apply even if they do not meet every listed qualification. The program values potential, motivation, and research curiosity over rigid credential requirements. This is the rarest kind of opportunity in technology. A company at the frontier of AI, one valued at over $900 billion offering outsiders direct access to its research infrastructure, its mentors, and its most important open problems. Paying them generously to do it. And then hiring 40% of them afterward. Most people who want to work on AI safety spend years trying to publish papers, get into the right PhD program, and find a way in. The Fellows Program is the door they did not know existed. It is open right now.

GLYPH – deterministic byte-exact retrieval over static corpora I built this because I kept running into the same problem: probabilistic retrieval finds candidates, but nothing confirms exact presence. GLYPH is not a search engine. Not a vector DB. Not a grep replacement. It indexes a static corpus once — suffix array + BWT + FM-index — and answers exact substring queries deterministically. Same bytes in, same result out, every time. Benchmark on 1GB HDFS logs: - 100 exact queries - grep: 11.5s - GLYPH persistent backend: 0.0017s total The tradeoff is real: offline indexing, high RAM, static corpus only. Not production-ready. Experimental. Happy to answer questions about the FM-index construction, sentinel semantics, or the segmented query path. 🏳️🏴

BM25 is lexical but still probabilistic — term frequencies, IDF weights, scoring. Fast lexical retrieval is not the same as exact retrieval. The next question after "23x faster search" is: how do you verify the result is actually there, byte for byte? Retrieval speed is solved. Retrieval certainty is not.

When you want to move from single agent SQLite on something like QMD, PostgreSQL is a great choice for multi agent and production quality, but not as snappy. So we made it much more snappy with BM25 & open sourced it. More soon for planetary scale sovereign agents

@ingliguori Both RAG and "LLM Wiki" still have the same problem: How do you verify the knowledge is actually there? Structured markdown evolves. Links break. Content drifts. You still need a layer that confirms exact presence. Compilation without verification is just prettier retrieval.

RAG is already becoming the “old way” 🤯 The future of AI memory is not retrieval. It’s compilation. Here’s the shift in one sentence: ➡️ From searching information ➡️ To structuring knowledge The new model? LLM Wiki Instead of: ❌ Chunking documents ❌ Running similarity search ❌ Losing context We move to: ✅ Structured Markdown knowledge ✅ Interconnected concepts ✅ Persistent memory ✅ AI-maintained systems Think of it as building a Second Brain for your AI. One that: 🧠 Remembers 🔗 Connects 📈 Evolves over time And the most interesting part? LLMs are not just thinkers. They are perfect librarians. They don’t get bored. They don’t forget to update. They don’t break links. They maintain knowledge better than we do. 📖 I wrote a deep dive on this transformation: go.kenovy.com/UjPa #AI #LLM #RAG #SecondBrain #Obsidian #FutureOfWork #Tech

@CodeEdison Rust for systems infrastructure is underrated here. Not AI tooling on top. The substrate underneath.

Skills That Pay in the AI Era (2026) AI/ML: Python, PyTorch, Transformers, Fine-tuning, Evaluation AI Stack: RAG, Vector Databases, Embeddings, Prompt Engineering, Agents Backend: Node.js, Go, Rust, API Design, System Design Frontend: React, Next.js (for AI apps & dashboards) APIs: REST, GraphQL, gRPC Databases: PostgreSQL, Redis, Vector DBs DevOps: Docker, Kubernetes, CI/CD, Terraform Cloud: AWS/GCP/Azure, Serverless, Edge (Cloudflare, Vercel) MLOps: Model serving, MLflow, Monitoring, Data pipelines Security: Auth, API Security, Zero Trust AI Productivity: Copilot, Cursor, Code review with AI Core CS: Data Structures, Networking, OS, Scalability

Why determinism is a performance principle The vector search industry has a problem: approximate systems are slow because they are unpredictable. When scoring requires looking up different memory locations per coordinate, CPU pipelines stall. When scoring is reducible to integer arithmetic over a fixed grid, SIMD runs at full speed. Predictability is not a nice-to-have — it is the mechanism of throughput. This pattern shows up clearly in recent quantization engineering work, for example Elasticsearch BBQ vs TurboQuant (Elastic, 2026). GLYPH takes this further. Not “more predictable approximate” but “exact by construction.” Think of it like a lock and key. Vector search hands you a pile of keys that probably fit. GLYPH tells you whether the exact key exists in the pile — byte for byte, every time, same answer. That is a different tool for a different job. And that is the point.