# AI เขียน Go โบราณตลอด — JetBrains เลยทำ "กติกาการเขียน Go สมัยใหม่" ให้ agent แล้ว

> Source: <https://dev.to/gophernment/ai-ekhiiyn-go-obraantld-jetbrains-elytham-ktikaakaarekhiiyn-go-smayaihm-aih-agent-aelw-2pid>
> Published: 2026-08-26 05:52:28+00:00

📅 เขียนเมื่อ: สิงหาคม 2026 | ครอบคลุม Go 1.0–1.27

⚠️ ข้อมูลอัปเดต ณ วันที่เขียน — เวอร์ชัน/ฟีเจอร์อาจเปลี่ยนตามรอบ release ของ Go

ถ้าคุณเคยให้ AI coding agent เขียนโค้ด Go ให้ ลองสังเกตดูว่ามันเขียนออกมาเป็นยังไง ส่วนใหญ่แล้วมันจะเขียนแบบ "รุ่นพ่อ" ออกมา — ใช้ `if a > b { return a }`

แทนที่จะใช้ `max(a, b)`

, เขียน loop หา element ทีละตัวแทน `slices.Contains`

, หรือประกาศตัวแปรชั่วคราวเพื่อเอา pointer แทนที่จะใช้ `new(...)`

โค้ดแบบนี้รันได้นะ ไม่ผิดด้วย แต่มันไม่ใช่ Go แบบที่เราเขียนกันในปี 2026 แล้ว และนี่คือปัญหาที่ทีม JetBrains มองเห็น แล้วทำของชิ้นหนึ่งออกมาแก้ตรงจุด — ชื่อว่า **go-modern-guidelines**

สาเหตุหลักมีสองอย่าง และมันซ้อนกันอยู่

**อย่างแรก** โมเดลภาษาเรียนรู้จากโค้ดบนโลก ซึ่งส่วนใหญ่เขียนขึ้นมาในช่วงหลายปีที่ผ่านมา โค้ด Go เก่า ๆ ที่วนอยู่ใน internet มหาศาลล้วนเป็นสไตล์ "ก่อนจะมีฟีเจอร์ใหม่" ทั้งนั้น โมเดลเลยจับ pattern แบบเก่ามาเป็น default

**อย่างที่สอง** Go ออกเวอร์ชันใหม่ทุก ๆ หกเดือน และแต่ละรอบก็มีของเล่นชิ้นเล็ก ๆ เข้ามาเรื่อย ๆ — `min`

/`max`

เข้ามาใน Go 1.21, `for i := range n`

ใน Go 1.22, `slices.Collect`

ใน 1.23, `t.Context()`

ใน 1.24, `errors.AsType`

ใน 1.26, และ `encoding/json/v2`

ใน 1.27 จังหวะมันไวกว่าที่โมเดลจะตามทัน

ผลลัพธ์คือ agent เขียนโค้ดที่ "ถูกแต่เชย" แล้วเราก็ต้องมาแก้ทีหลัง — ซึ่งก็คือสิ่งที่ Go team เองก็เห็นเหมือนกัน ถึงขั้นทำ analyzer ชื่อ `modernize`

เอาไว้ auto-update โค้ดเก่าให้เป็น idiom ใหม่

แทนที่จะรอให้โมเดลฉลาดขึ้นเอง ทีม JetBrains ทำสิ่งที่ตรงไปตรงมากว่ามาก คือเขียน**กติกา**ให้ agent อ่านแล้วทำตาม

`go-modern-guidelines`

เป็น repository ที่รวบรวม guideline 57 ข้อ ครอบคลุมตั้งแต่ Go 1.0 ยัน Go 1.27 แต่ละข้อประกอบด้วย "เขียนแบบนี้ ไม่ใช่แบบนี้" พร้อมโค้ดตัวอย่าง before/after ครบชุด แนวคิดง่าย ๆ คือให้ agent มี reference ที่ชัดเจนแทนที่จะเดาเอาเอง

ที่สำคัญคือมัน**ไม่ใช่แค่เอกสารอ่านเล่น** — ตัว guideline นี้ถูกแพ็กเป็น plugin/skill ให้ติดตั้งเข้าไปใน agent ได้ตรง ๆ รองรับทั้ง Junie, Claude Code, Codex, Cursor และ agent อื่น ๆ ผ่าน skills.sh พอติดตั้งแล้ว agent จะเรียกใช้ guideline นี้โดยอัตโนมัติตอนเจองานที่เกี่ยวกับ Go

ผมขอหยิบตัวอย่างที่เห็นแล้ว "นี่แหละ ที่ agent มักพลาด" มาให้ดูสักสองสามตัว

`min`

/ `max`

แทนการเทียบเอง (Go 1.21)

```
// แบบเก่า
if a > b {
    return a
}
return b

// แบบใหม่
return max(a, b)
```

`slices.Contains`

แทน loop หา (Go 1.21)

```
// แบบเก่า
found := false
for _, x := range items {
    if x == target {
        found = true
        break
    }
}

// แบบใหม่
found := slices.Contains(items, target)
```

`for i := range n`

แทนการนับเอง (Go 1.22)

```
// แบบเก่า
for i := 0; i < n; i++ {
    doSomething(i)
}

// แบบใหม่
for i := range n {
    doSomething(i)
}
```

`errors.AsType`

แทน `errors.As`

แบบเก่า (Go 1.26)

``` js
// แบบเก่า
var e *MyError
if errors.As(err, &e) {
    handle(e)
}

// แบบใหม่ — ได้ตัวแปรตรง ๆ ไม่ต้องประกาศไว้ก่อน
if e, ok := errors.AsType[*MyError](err); ok {
    handle(e)
}
```

มีอีกเพียบ — `clear(m)`

ล้าง map, `maps.Clone`

/`maps.Copy`

, `slices.Sorted`

เรียงจาก iterator, `sync.OnceValue`

สำหรับ memoize, `context.AfterFunc`

สำหรับ cleanup ตอน cancel ไปจนถึงของใหม่สุดอย่าง generic methods และ `encoding/json/v2`

ที่เพิ่งเข้าใน Go 1.27

เริ่มใช้งานง่าย ๆ — ถ้าใช้ Claude Code ก็สั่งติดตั้ง marketplace แล้วให้มันโหลด skill นี้เข้าไปได้เลย (คำสั่งติดตั้งครบอยู่ใน README ของ repo) หรือถ้าใช้ agent ตัวอื่นที่รองรับ skills.sh ก็แค่รัน

```
npx skills add JetBrains/go-modern-guidelines
```

แค่นี้ agent ของคุณก็จะรู้จัก idiom ใหม่ ๆ ของ Go แทนที่จะยึดติดกับสไตล์เก่า ๆ ที่มันจำมาจากโค้ดบน internet

ปัญหาที่ AI เขียน Go เชย ไม่ใช่เพราะโมเดลโง่ แต่เพราะข้อมูลเทรนเก่ากว่า release ล่าสุดของ Go ทางออกที่ JetBrains เสนอคือการยัด "ความรู้" เข้าไปใน context ของ agent ผ่าน guideline ที่ชัดเจน ซึ่งก็คือสิ่งที่ go-modern-guidelines ทำ — และมันไปทางเดียวกับ `modernize`

analyzer ของ Go team เป๊ะ

สำหรับใครที่ปล่อยให้ AI เขียน Go บ่อย ๆ ผมว่านี่เป็น skill ที่คุ้มค่าติดไว้ ไม่ต่างจากใส่ style guide ให้ทีม dev เลย

`modernize`

analyzer (เครื่องมือ auto-update โค้ด Go เก่าให้เป็น idiom ใหม่)