sermakarevich

Imo its a qualification issue. Companies, that do not have required qualification onboard are forced to enter new domain they do not understand.

If expertise is there, proper rules of using / benefiting from AI will be created rather sooner than later.

I am running an experiment with local qwen3.6:36B for a week: https://news.ycombinator.com/item?id=48520757

It really is better than I would expect it to be. But it requires a special treatment. Since the model is smaller it needs a smaller and simpler tasks. I use smarter model to decompose the task into primitive subtasks, write good description, submit to worker with qwen3.6, review completion and create new task to fix if required (20% of cases). This workflow works fine.

yes.

- smarter models to create tasks

- local qwen3.6:36B for tasks execution

here is how in details https://news.ycombinator.com/item?id=48520757

I think they do scale:

-- check this bug report from AMD where they say they run fleet of 50 agents 24x7 https://github.com/anthropics/claude-code/issues/42796

-- here I am running 3 coding agents 24x5 (not yet 7 so far) https://news.ycombinator.com/item?id=48520757

I was using multi-coding agents for poc projects first, now for production research and poc second and soon plan to get to production.

Trying to understand how to run many coding agents 24x7 https://news.ycombinator.com/item?id=48520757

AI or AI adoption?

AI in general is not slowing down. New smarter / bigger models popping up, get blocked, new open source models exceed commercial https://x.com/prz_chojecki/status/2065741640635990128?s=20. All is good here.

AI adoption is nowhere near the current capabilities of AI. I think its because of the lack of expertise at companies. Everyone has an opinion but in fact nobody knows how to work with AI. There is neither AI dedicated positions at companies nor AI transformation leaders on the market.

What companies can do in this case? Install Claude Code and wait how things change over time.

Not only SE career. Many careers which rely on static knowledge accumulated over years.

We have a senior guy who is like a walking cybersecurity library - knowing all the protocols, standards, vendors, threats. He is quite desperate atm. There is nothing he can add to what LLM already knows or can research in 30 seconds. He was building his profile for 30+ years.

I am on the side that AI will change everything. The reason why it has not yet is the lack of skills on the market - no AI transformation leaders. My strategy is to be closer to AI - number of nano startups with few people on board building smth AI related is exploding and they need expertise with AI engineering.

do you have something I can take a look at - post or git maybe ?

Love the approach. I am a big fun of hierarchical knowledge organization. I think that almost all current Claude abstractions to knowledge management are broken. It becomes visible when you start running many coders concurrently or need to create 1K+ skills fe: https://news.ycombinator.com/item?id=48407998

I started using brain -> workers approach for coding.

-- Brain is expensive smart model from claude subscription, Fable 5 when it was available, Opus now.

-- Worker is a local model (qwen3.6:46B), deployed in 36GB GPU, Opencode + Ollama.

Brain is responsible for analysis/design and task creation. Task should be made simple and clear so the worker can handle it. Worker does the coding. Brain validates and create a fix task when required. Atm fix to task ration is ~ 1:20.

If no available GPU at home - qwen3.6 is quite cheap on clouds.

Its rather experimental setup, out of curiosity, but it works better than I would expect it to. This allows me running 3 coding agents non stop for the 4-th day atm. Here I explain how I got there: https://news.ycombinator.com/item?id=48520757

It has to be coming from above. This is what McKinsey thinks and I think I agree. AI adoption required company transformation. This can't be done from the bottom - you will face severe resistance as this threatens people jobs/positions. Question is - how much you can extract from operational activity that can be automated reliably with AI. The more you can transform your company/operations in a way to maximize the AI automation - the bigger competitive advantage you get.

The problem companies are facing - is the lack of expertise. CEOs / Investors hear the rumors, AI can generate asymmetrical advantage - but no one knows HOW? And there are no AI transformation leaders on the market atm. So companies would try just to do something to be able to claim - we are on the road of AI adoption.

Using Claude Code for coding is a typical first move. Does it create a competitive advantage? It depends if company can ship features faster or cheaper. Otherwise it doesn't.

I have not heard of success stories about successful operational transformation based on AI. But I see a lot of nano-size startups popping up which build products on AI and embed AI into operations since the very early stage.

posting here on hacker news, always related to AI experiments

last one was - if I would have to run swarm of coding agents non stop, how this might look like

kimi k2.7 code looks great on this ranking https://x.com/prz_chojecki/status/2065741640635990128?s=20

I use qwen3.6:36B locally

```

I am doing this for my PoC projects ofc:

- improving fleet

- building a data collection and analysis related app

```

But main thing was curiosity if this is possible in general and if yes - how this might look like.

if you start recording your whole day including what you said/heard/seen you can build your persona LLM and leave it to your kids

I use SDD since Feb for all my mid+ size projects. This works great for me from many angles:

- two levels of task decomposition - first is multiple steps in workflow, second is task decomposition into multiple subtasks - help to keep session context clean and focused, thus improving adherence, reducing cost

- multiple levels of model understanding verification - you verify first requirements step, then design step and only later code implementation. This helps to ensure that even if miss implementation happens it is rather tactical, on a code level, than strategical - on design level

- agent works as a helper to analyze what you need to build, interview you, builds spec which is better than just short prompt

- works nicely with coding agents orchestrated around task queue

Started with GSD and later implemented my own to fit better my typical size of features.

AI:

- spec driven development workflow: https://github.com/sermakarevich/sddw

- fleet, orchestrator for running many coding agents: https://github.com/sermakarevich/fleet

- chunker, which builds smart chunks of the documents with hierarchical organization: https://github.com/sermakarevich/chunker

- ai knowledge wiki, a collection of ai papers and articles organized in hierarchical Wiki

- hierarchical organization of all passed Kaggle competition solutions (write ups and notebooks) - https://github.com/sermakarevich/kaggle_wiki

- claude code workflows, plugin to build custom claude code workflows based on ssd idea: https://github.com/sermakarevich/ccw

I have started testing roles separation:

-- Stronger model from claude subscription is responsible for analysis/solution design/task creation.

-- Cheaper model (qwen3.6, local deployment on 36GB GPU with 250K context size) is responsible for task execution

Doing this for less then 24 hours. Fable can monitor and validate execution and create smaller tasks when something has to be adjusted after qwen execution. It is slower ofc, but this can work non stop without hitting the limits even when using Fable for orchestration/monitoring. Using this app for orchestration: https://github.com/sermakarevich/fleet

There are other reasons why the roles separation might be important. Anthropic changes limits for claude -p next Monday. But even current limits are not great - they might be ok for occasional research but they burn within 2 hour of coding in interactive mode and 20 minutes if we use multiple workers. There are rumors that tokens we got within subscription fee for $200 is equivalent to 8-12K in API cost.

Question is what companies will do when subscription fee will be not enough even for coding. Paying x40 does not look like an option.

My strong opinion is that every SE should go for agentic engineering these days: understand the limitations, how to shift them, and how to squeeze the maximum possible out of AI. The AI boom is seeing hundreds of billions, close to a trillion, in investments — with yesterday's announcement from China about investing $300B in a nationwide grid of data centers. Models are becoming smarter, and the gap where yesterday's models were unable to do something is closing fast. I look at agentic engineering from the complexity perspective. Give an agent a simple task like inserting an assertion and you can be 100% sure it will do it correctly. Give it a complex task made of many subtasks in a complex codebase and it will fail. There is a boundary of complexity that a single call to an agent can handle. We can push this boundary if we decompose the task into many small ones and provide a sufficient description of what has to be done.

I found the Spec Driven Development approach works nicely for me, and I've been using it since Feb 2026 for all my mid+ size projects. I started with the GSD plugin, but it soon became too heavy, so I implemented my own lightweight SDD-based workflow for Claude. A friend of mine ported it to gemini-cli, and that version was added to Google's approved third-party frameworks for internal usage. The idea is to decompose feature implementation into multiple steps, task implementation into multiple subtasks, and be able to clear the context after every task/implementation.

Repo: https://github.com/sermakarevich/sddw

Slides: https://docs.google.com/presentation/d/1SjKXF7hkoqyiN9-3tBGY...

When SDD was not enough, I started playing with scaling a single AI worker to multiple, and then got to an agent swarm. Built on top of a centralized Beads database, claude -p headless execution, a UI, a custom ask_user MCP, and Telegram integrations, fleet (the app name) lets me add many tasks in advance, control the number of workers executing them, and use any kind of coder/model. It works nicely with the SDDW implementation phase. It shines when you keep creating tasks, define dependencies between them, and give clear descriptions. For personal projects I can queue up 70 tasks for an overnight run, set the number of workers to 1 to not be blocked by usage limits, and let it roll.

Repo: https://github.com/sermakarevich/fleet

Slides: https://docs.google.com/presentation/d/1O_pXyKdtpRG2ORD1xw7s...

Since Fable 5 appeared, I've been changing the way I work with fleet. Instead of adding tasks/descriptions/dependencies to fleet myself, I talk to Fable: specify the goal, ensure understanding, and let Fable 5 add tasks to fleet. Fable is expensive, but in this setup it doesn't code — it just investigates, designs, decomposes, and creates tasks. Workers use the cheaper Sonnet 4.6 model.

Reliability comes with task implementation decomposition into multiple steps, feature decomposition into many smaller and simpler subtasks, having better description, clean and focused context.

Main question is: what do you like? Do you like research, maybe automation, solving puzzles, constant learning requirement, fast changing domain? Check the attributes of software engineering and ask yourself if this is what you deeply love and can spend on it 10-14 hours a day.

I joined SE/DS/AI because I loved automation and research. And I have plenty of it on a daily basis no matter on what stage of its development compilers/llms are.

The rest are details and might be subjective. You don't need to understand LLM architecture to be able to use it - however this might be an interesting puzzle to solve. Many SE engineers don't write code and they did not write code even before LLM popped up - but they do research and solve design puzzles instead.

Good luck.

My feeling is that the reaction about new models is cooling down. At least at startups. At the beginning of the year few startup CEOs I know personally were expecting huge shifts in how companies work, headcount, efficiency, asymmetrical advantages created by ai in Q2-Q3. Now it seems like these expectation fade away. Companies don't have expertise onboard to rebuild itself to benefit from ai on a significant scale.

Fable 5 is out, metrics are better, but is your company flexible enough to benefit from it? What is your usecase?

there might be not much good enough solutions on the market yet that would substitute senior eng review

I am digging into this for some time and the main reason seems to be in definition of what good review is. Its less about finding bugs and more about code evolvability, maintainability and simplicity. without some context that would give a hint how the app will evolve over time, is maintained and what is simple/hard for live person - llm struggle to deliver useful insights here.

here you can find some related papers: https://github.com/sermakarevich/ai_knowledge_wiki/blob/mast...

I have this list on x of 67 people posting on AI related topics: https://x.com/i/lists/2014953069700633085

For papers/articles processing I use AI with pre-defined instructions to create short/medium summaries. The summary should give me good understanding of the main idea and if its worth reading it deeper. Even if not - main idea would be in your head.

These summaries I accumulate into hierarchical knowledge base, optimized for Obsidian and llms https://github.com/sermakarevich/ai_knowledge_wiki

git or versioned path on cloud storage should work. Format is more important - I think hierarchical knowledge base is the best thing on the market atm. You keep main page with refs and short summaries to 5-10 topics. Model reads it and decides where to drop down next. You optimize the breadth and depth of topics for optimal performance. Dropping down is not a through away tokens - this helps model to understand wider context.

I use it in quite a few repoes:

-- https://github.com/sermakarevich/ai_knowledge_wiki Curated extraction of summaries from AI-related research papers, organized as a hierarchical wiki optimized for Obsidian and LLMs

-- https://github.com/sermakarevich/chunker/tree/master/output/... Chunker processes a document into a hierarchy of self-sufficient chunks and multi-level summaries, producing a set of linked markdown files that an AI model (or a human) can explore through progressive disclosure -- starting from a high-level overview and drilling into details on demand, without ever loading the entire document.

-- https://github.com/sermakarevich/kaggle_wiki A structured knowledge base of Kaggle competitions — solutions, notebooks, and indexes — built for fast lookup and reuse.

Slides on fleet: https://docs.google.com/presentation/d/1O_pXyKdtpRG2ORD1xw7s...

Slides on fleet: https://docs.google.com/presentation/d/1O_pXyKdtpRG2ORD1xw7s...

TDD and specs help

I looked at most of those, including kiro and tessl. Was early user of GSD when it was suitable for mid+ size projects. Over time GSD grown into beast which is suitable for huge + size projects only producing gigantic specs and burning too many tokens for most of the tasks. So I decided to created my own, with set of steps I need and specs I want.

After few presentations of sddw to different companies, most important conclusion was that the ssd plugin should be customizable. It should fit the typical size of tasks/features you are working on, specs should fit your requirements, set of steps can be different.

So I created claude code workflow (ccw) which allows to compile custom version of workflow on top of sdd approach: https://github.com/sermakarevich/ccw

After making few presentations of sddw to different companies,

Here are some - I used sddw to create: - chunker - app to get smart slices from text and organize them in hierarchical LLM/Obsidian wiki. There were two features implemented using sddw and 15 subtags:

-- https://github.com/sermakarevich/chunker/blob/master/.sddw/c...

-- https://github.com/sermakarevich/chunker/blob/master/.sddw/m...

- ccw (claude code workflow - plugin to compile generic claude code workflows based on sdd approach) - https://github.com/sermakarevich/ccw/blob/main/.sddw/claude_...

Btw you can use ccw to create your own custom version of sddw quite fast - with specs format and sequence of steps that suit you best.

Time vs effort balance is very different for the two cases.

-- writing documents for each other takes weeks - write the document, give people time to review the document, discuss, update on review.

-- writing documents for Claude takes minutes rather than hour - AI is used to assist in writing specs, personal instead of collective review/approval process.

Also beneficiaries are different:

-- when you write spec for Claude - you benefit personally, you have higher chance of getting code you need from ai coder

-- when you write spec for the company - the company is the main beneficiary, it get higher chances to get teams on the same page with the change