@Yangtze_Seventh: Hot take: Skills are dying, methodologies live forever. Yesterday, I attended Bilibili's Build in Public event, and Tea…

Hot take: Skills are dying, methodologies live forever.

Yesterday, I attended Bilibili’s Build in Public event, and Teacher Kabi @jakevin7 actually put this line right into his PPT and shared it publicly! That was hands down the highlight of the entire afternoon—felt like I was straight-up in class!

The driest of the dry—too damn dry!

As Teacher Kabi put it, with models advancing through constant training, a ton of general knowledge and standard workflows will gradually get baked right into the models. Stuff that used to require a huge wall of instructions to teach it how to do things? In the future, a few sharp prompts might be all it takes to tap into those built-in capabilities.

That frees us up to focus more on: What problem are we tackling this time? What approach should we take? And how do we verify it actually nailed it?

These 8 points Teacher Kabi shared can be slotted straight into your daily prompts—they’ll massively boost your workflow efficiency. Pair ’em with your own insights; bookmarking this for sure:

1️⃣ First Principles -> Get the problem itself crystal clear first. Feed this to your Agent to snap it back to reality: Check if the issue reproduces, what’s the root cause, and how the results differ before/after the fix. Ensures the core problem exists and is actionable from the jump.

Teacher Kabi used the example of Claude solving Fermat’s Last Theorem as a timely case study—super on-point. After 100 rounds, how do you get Claude to remember what the hell the task even was?

2️⃣ Adversarial Review -> Spin up a dedicated nitpicker Agent. Have an Agent that wasn’t in on the build do an independent audit: Hunt for counterexamples, gaps, and failure cases, and demand it backs it all up with evidence.

At its core, it’s basically multi-Agent cross-validation—getting everyone to sign off on a result.

3️⃣ Ablation Experiments -> Yank out one thing and see if it still holds up. This is the non-negotiable step in paper-writing: Ablation Study. In plain terms, it’s about stripping out a key variable and gauging the impact on results.

To test if a rule, tool, or prompt chunk is actually useful, keep everything else steady, delete it, rerun, and compare outcomes. That’s the only way to prove every piece pulls its weight.

4️⃣ Occam’s Razor -> Ship the simplest version that works first. If a script can handle it, get that script running ASAP. Let the architecture evolve with real-world needs.

This lines up perfectly with what the Neko Girl Project founder shared at the start of the conference. Now that everyone’s Building in Public, if you’ve got an idea that works, throw it out there for review—gather real feedback and needs, and boom, your product levels up!

5️⃣ List All Your Insecurities -> Make room for doubt to surface. Explicitly task the Agent with confessing: Which conclusions lack evidence? Which scenarios haven’t been tested? Where’s it just spitballing?

Even the strongest Agents screw up (Astra’s 100% benchmark? Yeah, let’s table that for now). Self-checks are the only way to dial down error rates.

6️⃣ Preserve Independent Thinking -> Judge first, then peek at others’ takes. Especially in multi-Agent collabs, have each one drop their conclusion and reasoning solo before group chat. Makes it way easier to spot disagreements and avoid one Agent bullshitting while the rest nod along.

He dove deep later into multi-Agent setups too—Swarm, Graph, Agent Teams, and how to pick ’em.

7️⃣ Critical Thinking -> Vet the evidence, no exceptions. Don’t buy a polished analysis just ’cause it sounds airtight. Task the Agent with separating observed facts from guesses, and spell out what evidence would nuke its own call.

8️⃣ High Cohesion, Low Coupling -> Nail down those module boundaries. Bundle related logic together; let modules handshake via clean interfaces. This straight-up shapes how tough the Agent’s job is: The clearer the scope for tweaking one module, the easier it is to feed it the right context and test changes.

My read on “Skills are dying” mostly hits those rambling walls of generic knowledge dumps. Those 1000+ line explainers from back in the day? Pre-training’s internalized most of that now—a couple lines of text can deliver killer results.

Of course, skills aren’t just text; visuals, tool calls, and such still have their place.

Man, this session was a goldmine—total value bomb! Loved how Teacher Kabi turned engineering methods into stuff we can fire up next time we spin up an Agent. Some deep thinkers to chew on, some plug-and-play executables!

Shoutout to Teacher Kabi for the share—catch you next time!

真的受益匪浅！

如果预加载的话堆积在上下文，可能还没等执行任务就已经把1M限制打爆了。。

在我们的memory里面是支持wiki，如果涉及到了对应的任务才会高效的加载。日常使用的话我觉的涉及到一个完整的流程、重复的流程，新开一个窗口单独完成效率高很多。

其实日常使用完全够了，模型也越来越强，解决问题的能力也会越来越强

但上层肯定有人会想追求效率，追求更好的效果嘛，自然会有一些小技巧。我觉的AI 工具可以提高人的下限，但对不同人提高的程度也不一样嘛

哈哈其实不冲突，大模型会越来越强，之前的skill由于会占用太多上下文，现在都已经在预训练中内置好了，只需要一些名词来出发，这本身就是一种进步。

而且，大模型解决基础的任务已经非常足够了，如果有更高的开发需求和效率提升，才需要注意更多细节上的使用。

安装到本机最好是按照自己的工作习惯来做一些适配。开箱即用且好用的并不多