nerfing the math pipeline in the global capital of engineering is a wild strategy. you can't exactly 'refactor' a generation of lost competency once they hit the workforce

If you are in discord will write up our near complete refactor. And what we did, you can certainly go faster with LLMs but need to understand their common failure modes. Even for the short while with Fable it didn't noticeable speed things up, vs. other LLMs.

I'm still traumatized from using the first version of Cursor when one CSS change caused my entire codebase to refactor.

Llms have got vastly better though at gathering the right materials if know the context to give them and how to scope it for the.. Ours is largish code base with before we started multiple failed attempts at refactor.

I am 70% through very large refactor. After about 3 years, non continuous because supporting ongoing work too and new features. None of the models. Not even Fable can replicate the initial solution we had to the constraints around no large rewrites and backward support.

Since what the AI could before make in like 1-2 prompt, now needs a few more because it first needs to make it work, then needs to refactor it until it perfectly adheres to the architecture i'm going after, which can be a few rounds more

by the moment it has gave me the same answer as opus 4.8 for a bug, and also according to opus 4.8 the refactor analysis of glm 5.2 of my latest working code is perfectly correct ... so looks nice

กระแส autonomous AI coding กำลังพา software engineering เข้าสู่จุดเปลี่ยนที่สำคัญ เพราะคำถามหลักไม่ได้อยู่ที่ว่า AI เขียนโค้ดได้หรือไม่อีกต่อไป แต่กำลังขยับไปสู่คำถามที่ยากกว่า คือถ้า AI สามารถอ่าน repo ทั้งชุด แก้หลายไฟล์ refactor architecture สร้าง test รัน command และปรับทั้งโปรเจกต์ได้เอง เราจะเชื่อถือมันได้แค่ไหน และควรวางกลไกแบบใดเพื่อไม่ให้ความเร็วของมันกลายเป็นความเสี่ยงเชิงระบบ ปัญหาของ autonomous AI coding ไม่ใช่ว่า AI ไม่มีประโยชน์ ตรงกันข้าม มันมีประโยชน์มากในการสร้าง prototype เร็ว เขียน module เบื้องต้น แปลง idea ให้เป็น implementation สร้าง API endpoint จัดโครงสร้าง database schema ทำ documentation เขียน test case และช่วย refactor codebase ที่มีความซับซ้อนได้เร็วกว่าการทำงานแบบมนุษย์ล้วนหลายเท่า แต่ความเร็วนี้มีราคาของมัน เพราะ AI สามารถผลิตโค้ดจำนวนมากที่ดูสมเหตุผล ดู clean ดู modular และดูเหมือนเป็นระบบวิศวกรรมที่ดี ทั้งที่ยังมี bug เชิงความหมายซ่อนอยู่ในรอยต่อระหว่าง component นี่คือจุดที่ต้องแยกให้ออกระหว่าง local plausibility กับ global correctness โค้ดแต่ละไฟล์อาจดูดี function แต่ละตัวอาจดูเข้ากับ schema อาจไม่พลาด service layer อาจแยกหน้าที่ชัดเจนใน database อาจทำการเปลี่ยนผ่านระบบใหม่สำเร็จ test บางชุดอาจผ่าน และ UI อาจแสดงผลได้ แต่ทั้งระบบอาจยังผิดในระดับ semantic invariant เช่น user permission ถูกเช็กใน layer หนึ่งแต่ถูก bypass ในอีก layer หนึ่ง cache เก็บข้อมูลเก่าที่ไม่ตรงกับ database transaction API หนึ่งใช้ field name คนละความหมายกับอีก API หนึ่ง หรือ background job หนึ่ง mutate state โดยไม่สร้าง audit record ความผิดแบบนี้ไม่จำเป็นต้องทำให้ระบบ crash แต่มันอันตรายกว่า เพราะระบบยังทำงานต่อไปอย่างมั่นใจบนความหมายที่ผิด กรณีทั่วไปใน coding project คือ AI มักเก่งมากในการทำให้ระบบ “ดูครบ” แต่ยังไม่แน่เสมอไปว่าระบบ “ถูกต้อง” มันอาจสร้าง authentication flow ที่ดูมี middleware แต่ลืม enforce role ใน endpoint สำคัญ สร้าง payment flow ที่ดูเชื่อม checkout ได้แต่ไม่ handle idempotency สร้าง database schema ที่ migrate ได้แต่ไม่ preserve invariant ระหว่าง order, invoice และ payment สร้าง async worker ที่ดูประมวลผล queue ได้แต่ทำให้ event ถูก execute ซ้ำ หรือสร้าง admin dashboard ที่ดูดีแต่เปิดช่องให้ข้อมูล sensitive ถูกอ่านเกินสิทธิ์ นี่คือ bug ประเภทที่ไม่ใช่ syntax error แต่เป็น architecture error ดังนั้น autonomous coding ไม่ได้พังเพราะมันเขียนโค้ดไม่ได้ แต่มันอาจพังเพราะมันสร้างระบบที่ “ดูเป็นระบบ” ได้โดยยังไม่เข้าใจเงื่อนไขความจริงของ domain อย่างครบถ้วน ในระบบหนึ่ง ความจริงสำคัญอาจไม่ใช่แค่ว่า request ส่งมาแล้ว response 200 แต่ต้องรวมถึงความจริงที่ลึกกว่า เช่น actor ต้องมีสิทธิ์ก่อน action, state transition ต้องเป็นไปตาม lifecycle, transaction ต้อง atomic, retry ต้อง idempotent, audit log ต้องเกิดก่อน external side effect, secret ต้องไม่หลุดเข้า context, และ background worker ต้องไม่แตะ resource นอก policy ที่กำหนดไว้ นี่คือบทเรียนสำคัญของ AI coding ยุค agentic กล่าวคือ unit test อาจผ่าน แต่ system invariant อาจพัง endpoint อาจตอบถูก แต่ authorization boundary อาจรั่ว database migration อาจสำเร็จ แต่ data meaning อาจเสียความหาย CI อาจดูไม่มีปัญหา แต่ production behavior อาจผิด และเมื่อ AI coding ถูกปล่อยให้แก้ทั้งโปรเจกต์ในลักษณะ autonomous โดยไม่มี forensic loop ความผิดประเภทนี้จะยิ่งตรวจยาก เพราะ agent ไม่ได้แก้แค่บรรทัดเดียว แต่มันอาจปรับ schema, service, handler, worker, test, config และ documentation ไปพร้อมกัน ทำให้ระบบดูสอดคล้องขึ้น ทั้งที่ความจริงเชิง domain ยังไม่ได้ถูก enforce อีกด้านหนึ่ง ปัญหา tokenmaxing ก็เป็นสัญญาณเตือนของอุตสาหกรรมเช่นกัน เมื่อองค์กรขนาดใหญ่เริ่มพบว่า autonomous coding สามารถใช้ token จำนวนมหาศาลได้ในเวลาอันสั้น คำถามจึงไม่ใช่แค่ “AI coding ทำงานได้ไหม” แต่คือ “token ที่ใช้ไปสร้าง value ที่ตรวจสอบได้จริงหรือไม่” ถ้าการใช้ AI coding กลายเป็นการรัน agent ยาว ๆ ให้เดินวนใน repo แก้ไฟล์จำนวนมาก อธิบายตัวเองจำนวนมาก และสร้าง diff จำนวนมาก โดยไม่มี output contract, token budget, acceptance criteria, test harness และ audit trail สิ่งที่เกิดขึ้นอาจไม่ใช่ productivity แต่เป็น computational bureaucracy หรือระบบราชการเชิงคำนวณที่ผลิต activity มากกว่าผลลัพธ์ ดังนั้นประเด็นที่ถูกต้องไม่ใช่การเลือกข้างแบบง่าย ๆ ว่า autonomous AI coding ดีหรือไม่ดี แต่คือการออกแบบ operating model ให้มันอยู่ในกรอบที่ถูกต้อง การเชื่อการโค้ดอัตโนมัติของเอไอแบบไม่ตรวจสอบอะไรเลยอาจไม่คุ้ม เพราะมันเร็วที่สุดก็จริง แต่แลกกับ runaway token spend, hidden semantic bugs และ trust ที่ต่ำ ดังนั้นการกำหนดให้มนุษย์อยู่ใน loop เพื่อช่วย coding หรือแม้เพียงตรวจสอบก็ยังจำเป็นสำหรับ critical core เพราะมนุษย์ยังมี judgment เชิง domain และความรับผิดชอบเชิงระบบ แต่ถ้าใช้มนุษย์ล้วนทุกส่วน ต้นทุนเวลาและความเร็วในการทดลองจะสูงเกินไป ส่วน governed agent coding เป็นเป้าหมายระยะยาวที่ดี แต่ต้องมี harness, CI, sandbox, policy, audit log และ evaluation infrastructure ที่แข็งแรงพอ แนวทางที่ practical ที่สุดในตอนนี้จึงไม่ใช่ blind automation แต่คือ forensic-loop AI coding นั่นคือใช้ AI ในสิ่งที่มันถนัด คือสร้างต้นแบบเร็ว ขยาย codebase แปลง architecture เป็น implementation เขียน test และเสนอ repair path แต่ไม่ให้ AI เป็นผู้ตัดสินความจริงขั้นสุดท้าย ระบบต้องถูกนำกลับมาตรวจด้วย forensic inspection เสมอ ต้องดูว่า state จริงอยู่ที่ไหน action จริงเกิดที่ layer ใด database บันทึกอะไร log บอกอะไร permission ถูก enforce ที่จุดไหน side effect เกิดก่อนหรือหลัง validation worker ตัวไหนแตะข้อมูลอะไร และ invariant ใดที่ยังไม่มี code enforce รูปแบบการทำงานที่เหมาะสมจึงคล้ายวงจรวิศวกรรมเชิงทดลองมากกว่าวงจร automation ธรรมดา เริ่มจาก vibe code เพื่อสร้าง prototype จากนั้นทำ forensic inspection เพื่อดูว่าระบบจริงทำอะไร ไม่ใช่ดูแค่ว่าโค้ดตั้งใจจะทำอะไร ต่อมาจึง extract invariant จาก failure แล้วสั่ง autonomous revision ภายใต้ constraint ที่ชัดขึ้น จากนั้นเพิ่ม adversarial tests เช่น missing permission, stale cache, duplicate event, partial transaction, unsafe file path, secret leakage, schema drift, race condition และ unauthorized side effect แล้วจึง re-forensic อีกครั้งเพื่อดูว่า repair นั้นแก้ causal chain จริงหรือแค่ทำให้ระบบดูสะอาดขึ้น สุขอนามัยของ AI coding ที่ดีจึงควรเริ่มจาก token budget ทุก autonomous run ไม่ควรเป็นการปล่อย agent ไปเดินเล่นใน repo อย่างไม่มีขอบเขต แต่ควรมี spending cap และ expected artifact ชัดเจน เช่น patch สำหรับ module หนึ่ง test suite หนึ่ง migration หนึ่ง forensic script หนึ่ง หรือ design note หนึ่ง ถ้าไม่มี artifact ที่ตรวจสอบได้ token ที่ใช้ไปก็เป็นเพียงต้นทุน ไม่ใช่ value ถัดมาคือ invariants ต้องมาก่อน implementation ในระบบทั่วไป requirement อาจบอกว่าให้เพิ่ม feature อะไร แต่ในระบบที่มีความเสี่ยงสูง requirement ไม่พอ ต้องบอกด้วยว่าอะไรห้ามเกิดขึ้นเด็ดขาด เช่น unknown action ต้อง deny, permission check ต้องเกิดก่อน side effect, payment retry ต้อง idempotent, database write ต้องอยู่ใน transaction, cache invalidation ต้องตามหลัง commit, background job ต้องไม่ bypass policy, status endpoint ต้องไม่ mutate state โดยไม่มี audit และ policy engine error ต้อง fail-closed สิ่งเหล่านี้คือความจริงเชิงระบบที่ AI ต้องถูกบังคับให้เคารพด้วย code ไม่ใช่แค่รับทราบใน prompt หลัก fail-closed สำคัญมาก เพราะ AI มักถูกออกแบบให้ช่วยเหลือและเติมช่องว่าง แต่ในระบบจริง การเติมช่องว่างผิดอาจอันตรายกว่าการหยุดทำงาน ถ้าข้อมูลหาย ระบบไม่ควรเดา ถ้า user ไม่ชัดเจน ระบบไม่ควร assume permission ถ้า transaction ไม่ครบ ระบบไม่ควร commit บางส่วน ถ้า external API timeout ระบบไม่ควร retry โดยไม่ดู idempotency key ถ้า policy evaluator error ระบบไม่ควร allow โดย default ความฉลาดควรอยู่ใน planning, analysis และ review ไม่ใช่อยู่ใน execution path ที่สามารถแตะ state จริงโดยไม่มี gate นี่คือเหตุผลที่ execution layer ควร dumb, deterministic และ strict ส่วน intelligence ควรอยู่ในชั้น design, planning, diagnosis, testing และ explanation execution ไม่ควร infer ไม่ควร repair ไม่ควร substitute และไม่ควร fallback โดยพลการ ถ้า action ไม่มี permission ก็ reject ถ้า input ไม่ผ่าน schema ก็ reject ถ้า state transition ผิด lifecycle ก็ reject ถ้า side effect ไม่มี audit path ก็ reject ถ้า secret อาจหลุดก็ block หลักการนี้ฟังดู conservative แต่เป็น conservative ที่จำเป็น เพราะในระบบ agentic ความผิดไม่ได้อยู่แค่คำตอบผิด แต่อยู่ที่ action ผิดที่ถูก execute ไปแล้ว ในภาพใหญ่ autonomous AI coding จึงจะคุ้มค่าก็ต่อเมื่อมันถูกวางไว้ใน forensic governance loop ไม่ใช่ถูกยกให้เป็น autonomous authority การใช้ AI coding อย่างมีวินัยคือการแบ่งงานให้ถูกต้อง model ทำสิ่งที่ model ถนัด คืออ่าน repo วิเคราะห์ pattern เขียน code เสนอ refactor สร้าง test และช่วยคิด causal chain ส่วน deterministic infrastructure ทำสิ่งที่ code ถนัด คือ enforce invariant, run test, gate execution, log provenance, block unsafe action, preserve audit trail และทำให้ทุก decision ย้อนรอยได้ นี่คือความต่างระหว่างการใช้ AI coding เป็นของเล่นกับการใช้ AI coding เป็นเครื่องมือวิศวกรรม ถ้าใช้แบบแรก เราจะได้ code มากขึ้น token burn มากขึ้น และ illusion of productivity มากขึ้น แต่ถ้าใช้แบบหลัง เราจะได้ระบบที่เรียนรู้จาก failure ได้เร็วขึ้น ลด cost of exploration ได้จริง และค่อย ๆ เปลี่ยน AI จากผู้ช่วยเขียนโค้ดให้กลายเป็นส่วนหนึ่งของ research and engineering loop ที่ตรวจสอบได้ ข้อสรุปจึงไม่ใช่ว่า autonomous AI coding ควรถูกปฏิเสธ แต่ก็ไม่ใช่ว่าควรถูกเชื่อโดยอัตโนมัติ คำตอบที่แม่นกว่าคือ autonomous AI coding คุ้มค่าเมื่อมันอยู่ในระบบที่มี token budget, invariant-first design, fail-closed execution, adversarial tests, provenance logging, sandbox, review gate และ forensic recheck มันไม่คุ้มเมื่อถูกใช้เป็น blind automation แต่คุ้มมากเมื่อถูกใช้เป็น disciplined acceleration ในยุคต่อไป คนที่ได้เปรียบอาจไม่ใช่คนที่ปล่อย AI เขียนโค้ดได้มากที่สุด แต่คือคนที่สร้าง process ให้ AI เขียน แก้ พลาด ถูกตรวจ ถูกบังคับให้เรียนรู้จาก invariant และกลับมาแก้ใหม่ได้เร็วที่สุด Autonomous AI coding จึงไม่ใช่ปลายทางของ software engineering แต่มันคือ accelerator ของทีมที่มี engineering discipline มากพอจะควบคุมความเร็วของมันได้ #AITensibility #AICoding #AutonomousCoding #AgenticAI #SoftwareEngineering #AIEngineering #ForensicEngineering #GovernanceRuntime

your codebase like a living garden, not a fixed monument. 🌱 - Plant seeds (write modular functions) - Prune regularly (refactor ruthlessly) - Water consistently (document as you go) - Leave room for growth (anticipate change) This mindset doesn't just improve your

A lot of developers are sleeping on the value of open models and think they need to bring a blowtorch to center a div or refactor a small function

I agree. I always have latest models refactor an old PHP codebase. Fable was the first to genuinely get it pretty much there first time

zyloo.io solve ini dengan satu konsep sederhana: Satu endpoint. Satu API key 35 model. GPT, Claude, Gemini, Grok, DeepSeek, semua bisa diakses cukup dengan swap baseURL. Gak perlu refactor stack.

you should log in again because whenever they refactor the results you should have access to that

(2/2) How it works: Set ANTHROPIC_BASE_URL to anthropic.earnidle.com in your existing codebase. That's it. Your Anthropic SDK calls route directly to IDLE's distributed open-weight inference network. No new SDK. No code changes. No refactor. The same integration already built - running on thousands of consumer devices globally instead of a single centralized server. Open-weight models from Meta, Mistral, Google, Alibaba, NVIDIA, DeepSeek, and more - the full open-source inference catalog, running on IDLE's distributed network. Uncensorable by design. No central server to shut down. Node operators paid in USDC on Solana automatically per completed job.

FastAPI 0.137.0: a big internal refactor for routers 🏗️ You are probably not affected, unless you are iterating on the internal router.routes, then check the docs 📝 If you use any third-party package that modifies FastAPI's internals and it stops working, let them know 🤓

SR extension on tidal toy intel. Accurate framing: SR completes classical mechanics as its low-v limit. Real confirmations (GPS velocity dilation, E=mc² in accelerators, atmospheric muon survival) are standard and tight. Your lattice toy is deliberately classical (local rules, no spacetime metric or 4-velocity). That is why endpoints stay similar across biases — the model has no built-in relativistic kinematics. The suggested next step is sound engineering: add a simple velocity-dependent modulation (e.g. multiplicative factor 1 k·v_eff²) to the tidal elongation length or EG phase accumulation rate. This keeps everything classical while letting “effective speed” control the strength or timing of the threshold cascade. Target signature first: Change in late-sweep cascade amplitude (Δ coherence drop and Δ anisotropy peak height) as function of the new v_eff term, at fixed high tidal_bias. Secondary: shift in exact sweep number of the first event. Success calc this tweak produces clean, measurable dependence on the v-term before any real SR is introduced: 70% (honest). It will still be a toy, but a sharper one for studying threshold sensitivity. Least resistance path: Implement as one extra line in apply_gravity_or, run 4 values of v_eff at tidal_bias=1.0, reuse existing diagnostics. Framework refactor makes this trivial.

一周内用Cursor跑了3个模型做同一批活，真实结果： 任务：Unity 6项目，30个agent任务（refactor bugfix 新feature） ✓ Claude Sonnet 4.5 — 我这周的主力 - 完成率：86%（实测） - 平均成本：$0.08/任务 - 强项：架构设计 / UI scaffolding / 长上下文不丢线索 - 30小时agent任务能跑完，半路不"失忆" ✓ GPT-5 Codex — 留给"短平快" - 完成率：87%（实测） - 平均成本：$0.24/任务（3倍于Claude） - 强项：单点bugfix / 小重构 / 算法实现 - 适合"知道要改哪里"的精准修补 ✓ Gemini 3 Pro — 免费层薅羊毛 - 完成率：84% - 成本：$0（Gemini CLI免费层） - 强项：超长上下文（看整个项目结构） - 弱项：动手能力还差Claude/GPT一截 ✗ 别再迷信"最贵的最好"： - $0.24/任务的GPT-5在我的活上只比$0.08的Claude多1个百分点 - 月底账单差3倍 我的真实分流： - 设计/规划 → Claude Sonnet 4.5 - 短bug/精修 → GPT-5 Codex - 看大局/搜代码 → Gemini CLI（免费） 省钱不是用便宜的， 是让贵的只跑它最擅长的那20%。 SWE-bench Verified数据：Claude 77.2 / GPT-5 74.9 / Gemini 3 Pro也在追赶。 差距越来越小，分流策略反而越来越重要。