วันนี้ผมไปอ่านบทความ “The Bitter Lesson” ของ Rich Sutton ที่เขียนไว้ตั้งแต่ปี 2019 — ย้ำนะครับ ปี 2019 ก่อนจะมี ChatGPT moment ด้วยซ้ำ แต่พออ่านจบแล้วรู้สึกว่ามันโคตรจริงกับสิ่งที่เราเจอกันทุกวันนี้

ใจความสั้นๆ ของบทความคือ Sutton บอกว่า บทเรียนที่ใหญ่ที่สุดจาก 70 ปีของงานวิจัย AI คือ วิธีที่ leverage “computation” (search + learning) มันชนะวิธีที่พยายามยัด “ความรู้ของมนุษย์” ใส่เข้าไปเสมอ และชนะแบบขาดลอยด้วย

เขายกตัวอย่างเยอะมาก — หมากรุก (Deep Blue ชนะ Kasparov ด้วย brute-force search ไม่ใช่ความเข้าใจหมากรุกแบบมนุษย์), โกะ (AlphaGo), speech recognition, computer vision ทุกอันเป็น pattern เดียวกันหมด คือช่วงแรกคนทุ่มแรงไปกับการใส่ knowledge ของมนุษย์เข้าไป มันช่วยได้ในระยะสั้น ทำให้คนวิจัยรู้สึกดี แต่พอ computation มันถูกลงเรื่อยๆ (Moore’s law) สุดท้ายวิธีที่ scale ด้วย compute ก็แซงหมด แล้วของที่อุตส่าห์ใส่เข้าไปกลายเป็นตัวถ่วง

ที่มันขม (bitter) คือคนวิจัยไม่อยากยอมรับ เพราะมันเหมือนแพ้ให้กับวิธีที่ “ไม่สวยงาม” ไม่ได้ใช้ปัญญาของเราเท่าไหร่

ทีนี้พออ่านจบ ผมกลับมามองสิ่งที่เราทำกันทุกวันนี้ในวงการ AI/coding agent แล้วเห็นภาพเดียวกันเป๊ะ

เราชอบยัดทุกอย่างเข้าไป — product skills เต็มไปหมด, MCP ต่อกันรัวๆ, agent ที่ซับซ้อนเกินความจำเป็น เราพยายาม build “วิธีที่เราคิดว่าเราคิด” ใส่เข้าไปในระบบ เพราะมันทำให้เรารู้สึกว่าเราคุมมันได้ มันช่วยได้จริงในระยะสั้น

แต่บทเรียนขมๆ อันนี้บอกเราว่า สิ่งที่เราอุตส่าห์ใส่เข้าไปวันนี้ อาจกลายเป็น constraint ในวันหน้า หรือกินทรัพยากรเกินกว่าที่จำเป็นจริงๆ พอ model รุ่นใหม่ที่ฉลาดกว่าและ compute ที่ถูกกว่ามันมา สิ่งที่เรา over-engineer ไว้ก็จะกลายเป็นภาระที่ต้องมานั่งรื้อ

สิ่งที่ผมว่าสำคัญที่สุดจากบทความนี้คือเรื่อง balance — ระหว่างสิ่งที่ “คนวิจัย/คนทำอยากทำ” กับสิ่งที่ “จะกลายเป็นข้อจำกัดในอนาคต” มันเป็น loop ที่วนซ้ำมาแล้วซ้ำอีก บทความเขียนตั้งแต่ปี 2019 แต่ pattern เดิมก็ยังกลับมาเรื่อยๆ ไม่เคยหาย

ยาวไปไม่อ่าน สรุปก็คือ:

  1. วิธีที่ scale ด้วย computation (search + learning) ชนะการยัด knowledge ของมนุษย์เสมอ — เพราะ compute มันถูกลงเรื่อยๆ
  2. การใส่ความรู้ของเราเข้าไป ช่วยระยะสั้นเสมอ และทำให้เรารู้สึกดี แต่ระยะยาวมันมัก plateau แล้วกลายเป็นตัวถ่วง
  3. อย่า over-engineer — อย่ายัด skill / MCP / agent ที่ซับซ้อนเกินจำเป็น เพราะของที่เราใส่วันนี้อาจเป็น constraint ในวันหน้า
  4. โจทย์จริงคือ balance ให้เป็น ระหว่างสิ่งที่เราอยากทำ กับสิ่งที่จะกลายเป็นข้อจำกัดตอน compute/model รุ่นใหม่มา

แนบ link บทความไว้ให้ครับ ลองไปอ่านกันดู สั้นๆ แต่ทรงพลังมาก อ่านปี 2026 แล้วยิ่งเข้าใจ — The Bitter Lesson

ใครอ่านแล้วคิดเห็นยังไงมาแลกกันได้นะครับ

Today I read Rich Sutton’s essay “The Bitter Lesson,” written back in 2019 — yes, 2019, before there was even a ChatGPT moment. And once I finished it, it struck me how brutally true it still is for what we deal with every single day now.

The gist is this: Sutton argues that the biggest lesson from 70 years of AI research is that methods which leverage raw computation (search + learning) always beat methods that try to cram in human knowledge — and they win by a wide margin.

He gives a lot of examples — chess (Deep Blue beat Kasparov with brute-force search, not human-style understanding of the game), Go (AlphaGo), speech recognition, computer vision. Every one follows the same pattern: early on, people pour effort into baking in human knowledge. It helps in the short term, and it feels good to the researcher. But as computation keeps getting cheaper (Moore’s law), the approach that scales with compute overtakes everything — and the knowledge we so carefully built in turns into dead weight.

The bitter part is that researchers don’t want to admit it, because it feels like losing to a method that isn’t “elegant” — one that barely uses our cleverness at all.

Once I finished the essay, I looked back at what we’re doing today in the AI / coding-agent space, and it’s the exact same picture.

We love stuffing everything in — product skills everywhere, MCP servers wired up back to back, agents more complex than they need to be. We keep trying to build “how we think we think” into the system, because it makes us feel like we’re in control. And it genuinely helps in the short term.

But this bitter lesson tells us: what we work so hard to build in today can become tomorrow’s constraint, or eat far more resources than it needs to. The moment a smarter new model and cheaper compute arrive, everything we over-engineered turns into baggage we have to rip back out.

The most important takeaway for me is balance — between what “the researcher/builder wants to do” and what “will become a constraint down the road.” It’s a loop that repeats over and over. The essay was written in 2019, yet the same pattern keeps coming back and never really goes away.

TL;DR:

  1. Methods that scale with computation (search + learning) always beat cramming in human knowledge — because compute keeps getting cheaper.
  2. Building in our own knowledge always helps in the short term and feels satisfying, but long term it tends to plateau and become a drag.
  3. Don’t over-engineer — don’t pile on skills / MCP / agents more complex than needed, because what you add today can be a constraint tomorrow.
  4. The real skill is balance: between what you want to build and what becomes a limit once the next wave of compute/models shows up.

Here’s the link — short but powerful, and it hits even harder reading it in 2026: The Bitter Lesson

Read it and let me know what you think.