A deeply over-engineered approach to printing one line of text.
Photo by Franco Antonio Giovanella on Unsplash
เฮลโหลวววว~ สวัสดีครับพี่ ๆ เพื่อน ๆ น้อง ๆ ทุกคน 🙏
ผมหายเข้าป่าห่างหายจากการเขียน blog ไปนานมากกกกก ฮ่าๆ
ช่วงที่ผ่านมาโดน AI ลากไปซ้อมอยู่พักใหญ่ จนแทบลืมไปแล้วว่าสมัยก่อนมนุษย์เราเขียนโปรแกรมกันยังไง
วันนี้เลยอยากกลับมาเขียน blog ที่โคตรรรรจะมีสาระสุดๆ(ประชด) รับปีม้าไฟ
ด้วย experiment ที่เรียกได้ว่ายากเอาเรื่องพอสมควรสำหรับปี 2026 นี้
นั่นคือการย้อนกลับไปแตะรากฐานสำคัญของวงการ Software Engineering อีกครั้ง
ด้วยการสร้าง Hello, World! ผ่านเทคนิคสุดคลาสสิกที่มีชื่อว่า Manual Typing
เป้าหมายของ experiment นี้ก็ตั้งไว้แบบตึงๆ แบบตึงโป๊ะเลย คือผมจะทำให้มันสามารถใช้งานได้จริงในระดับ Production Grade ด้วย
เอาละ เกริ่นยาวเหนื่อยพิมพ์ (เพราะพิมพ์เอง) ไม่เล่นละ เข้าโหมดจริงจังกัน ข้างล่างนี้จะเป็นสาระล้วนๆ เตรียมสมองของคุณไว้ให้ดี… มา ลุยกันเลย
Introduction
ในยุคที่ AI สามารถทำ everything jingle bell, generate code, explain architecture, debug issue, summarize PR และบางครั้งอาจดูเข้าใจ project เรามากกว่าเจ้าของ repo ไปอี๊ก
ผมเริ่มตั้งคำถามสำคัญขึ้นมาข้อหนึ่ง…
เรายังสามารถสร้าง software ได้อยู่ไหม หากไม่มี AI ช่วย?
คำถามนี้ไม่ใช่แค่คำถามเชิงเทคนิค
แต่มันคือคำถามเชิงอัตลักษณ์ของวิชาชีพ
ในฐานะคนที่อยู่กับ software engineering มานานพอที่จะเห็นหลายยุคผ่านไปผ่านมา ผมเลยตัดสินใจทำการทดลองที่มีความเสี่ยงสูง ความยากระดับ level 99
คือผมจะลองสร้าง software ที่สามารถแสดงผลข้อความ Hello, World!
โดยใช้เทคนิคขั้นสูงที่เรียกว่า
Manual Typing
ใช่ครับ ผมจะ generate code อันนี้ด้วย “มือและนิ้ว” มนุษย์! 🙌
Why Hello World?
หลายคนอาจสงสัยว่าทำไมถึงเลือก Hello World เป็น use case แรกของงานวิจัยนี้เพราะมันคือ one of the most iconic workloads ในวงการ software engineering เป็น benchmark ระดับ foundational และเป็นสนามทดสอบที่เหมาะสมสำหรับ validating cutting-edge input methodologies
พูดง่ายๆ ก็คือ
ถ้าเทคนิค Manual Typing นี้ยังไม่สามารถพาเราไปถึง Hello, World! ได้
ผมคิดว่าเราก็ไม่ควรฝันไปถึง Clean Architecture หรืออะไรอีกต่อไป
ดังนั้นผมจึงจำกัด scope ของ phase แรกไว้ที่ objective เดียว คือ!:
Hello, World!แม้จะดูเหมือนเป็น requirement ที่เรียบง่าย แต่ในเชิง implementation จริง มันซับซ้อนกว่านั้นมาก เพราะ..
- เราต้องคิด
- เราต้องพิมพ์
- เราต้องสะกด world ถูก
- และทั้งหมดนี้ต้องเกิดขึ้นโดยไม่มี llm มา hold our hand (ฟังดูหวานจัง)
What is Manual Typing?
แล้ว Technic Manual Typing นี่มันคืออะไร?
Manual Typing คือเทคนิคการสร้าง source code โดยอาศัยการประสานงานระหว่าง
- สมองมนุษย์
- ระบบประสาท
- กล้ามเนื้อมัดเล็ก
- keyboard input hardware
- และความกล้าหาญในระดับที่หาได้ยากในปี 2026
นิยามอย่างเป็นทางการของมันคือ:
A human-centered code generation process in which characters are physically entered into an editor one by one, without AI-assisted synthesis.
หรืออธิบายแบบภาษาชาวบ้าน:
คิดเอง แล้วพิมพ์เอง si-va
ซึ่งมันอาจฟังดูง่าย
แต่ในความเป็นจริงแล้ว นี่คือ distributed real-time system ที่มี latency, coordination overhead, และ failure mode จำนวนมาก เพราะระบบนี้ต้องอาศัย human operator ที่สามารถ:
- สร้าง intent ในสมอง
- map intent เป็น character sequence
- ระบุตำแหน่ง key บน keyboard
- execute physical key press อย่างแม่นยำ
- monitor output แบบ near real-time
ซึ่งผมก็ยังไม่อยากใช้คำว่า revolutionary เร็วเกินไป แต่ก็ไม่อยากปิดโอกาสของคำนี้เช่นกัน
High-Level Architecture
ทีนี้เราลองมาดู design ที่วางไว้แบบ High-Level Architecture เพื่อรองรับ workflow นี้ ซึ่งผมได้ออกแบบ Manual Typing stack ไว้ประมาณนี้
+----------------------+
| Human Brain Core |
| (Intent Engine) |
+----------+-----------+
|
v
+----------------------+
| Neural Transport |
| (Signal Dispatch) |
+----------+-----------+
|
v
+----------------------+
| Fingers Interface |
| (Input Executors) |
+----------+-----------+
|
v
+----------------------+
| Keyboard Grid |
| (Character Matrix) |
+----------+-----------+
|
v
+----------------------+
| Editor Layer (Xcode)|
| (Visual Rendering) |
+----------+-----------+
|
v
+----------------------+
| Swift Runtime |
| (Execution Engine) |
+----------+-----------+
|
v
+----------------------+
| Terminal Output |
| (User-Facing UI) |
+----------------------+architecture นี้จะถูกออกแบบเป็น event-driven, human-orchestrated, low-dependency system โดยมี event ที่สำคัญคือ:
KeyPressedนั่นจะหมายความว่า ทุกครั้งที่ event นี้เกิดขึ้น จะมี character หนึ่งตัวถูก materialize ลงบน editor จนกระทั่งเกิด source code artifact ที่ compile ได้ และผมเองก็จะบอกว่านี่ไม่ใช่แค่การพิมพ์ นี่คือ character-level progressive code synthesis
Implementation Strategy
ถัดมาใน implementation phase เราเริ่มต้นด้วยการเตรียม environment สิ่งที่ต้องใช้มีดังนี้:
- MacBook or PC
- Keyboard
- Xcode (หรือ IDE อะไรก็ได้จ้า)
- Fingers (1 นิ้วเป็นอย่างน้อย)
- confidence ที่เปี่ยมล้น
- เวลาที่เหลือเฟือ
- ความพร้อมที่จะ commit กับเทคนิคที่ industry ทิ้งไปแล้ว
ซึ่งถ้าของด้านบนครบแล้ว เราก็มา initiate Manual Typing session กัน
เริ่มจาก…
สูดหายใจลึกๆ
วางนิ้วลงบน keyboard
focus ลมหายใจ
stabilize intent
แล้วเริ่ม execute key-by-key generation
ซึ่งผลลัพธ์ของการ implementation พิมพ์ต๊อกๆแต๊กๆ รอบแรกของเราจะเป็น:
print("Hello, world!")อย่าพึ่งกด run! เพราะจะขอเน้นอีกครั้งว่า code นี้ไม่ได้มาจาก AI
ไม่ได้มาจาก prompt ไม่ได้มาจาก code completion
มันคือ fully hand-crafted code!!!
Character-Level Execution Model
ก่อนที่เราจะไปกด run หนึ่งในความท้าทายสำคัญของ Manual Typing นั้นคือระบบนี้ไม่ได้ generate code เป็น block แต่มัน generate ทีละ character นั่นหมายความว่า source code ที่เราทำ จะถูกสร้างผ่าน micro-operations ต่อไปนี้:
p
r
i
n
t
(
"
H
e
l
l
o
,
W
o
r
l
d
!
"
)โดยแต่ละ character ที่ถูกบรรจงกดผ่าน keyboard นั้นจะต้องผ่าน lifecycle ดังนี้
- Ideation (คิดก่อนว่าจะพิมพ์ตัวอะไร)
- Neural dispatch (สมองสั่งการไปยังนิ้ว)
- Finger routing (นิ้วเล็งหาปุ่มบนคีย์บอร์ด)
- Key impact (กดปุ่มนั้นจริง ๆ)
- Visual confirmation (เห็นตัวอักษรโผล่บนหน้าจอ)
ซึ่งนี่เลยทำให้ Manual Typing มีคุณสมบัติเด่นหลายอย่าง เช่น
- extremely transparent (รู้ว่าทุกตัวอักษรมาจากไหน)
- highly observable (เห็นทุกขั้นตอนแบบ real-time)
- naturally rate-limited (เร็วได้เท่าที่นิ้วจะไปไหว)
- impossible to scale carelessly (จะพิมพ์มั่วทีละพันบรรทัดยากมาก)
และจุดนี้เองที่ผมมองว่าเป็น strength! เพราะในยุคที่โค้ดเกิดเร็วเกินกว่าที่คนจะอ่านทัน Manual Typing บังคับให้เราช้าพอที่จะเห็นทุกตัวอักษรแบบที่เกิดขึ้นต่อหน้าต่อตา เหมือนกาแฟ slow bar แต่ว่าอันนี้เป็น slow ใจ… อะไร๊! slow code ดิ
Production Validation
หลังจาก implementation เสร็จ เราก็มาถึง validation phase กัน ผมจะรันโปรแกรมและมาดู output รวมถึงเตรียมพร้อมรับมือกับ worst-case scenario เช่น typo, syntax error หรือ bugs ต่างๆที่อาจจะเกิด แบบใจตุ้มๆต่อมๆ และผลลัพธ์ที่ได้ก็คือ:
Oh, myyy goshhh. It works!
เย่… วู้ว มี Hello, World!เกิดขึ้นมาจริงๆบน terminal ตรงตาม acceptance criteria ที่เราตั้งไว้ทุกประการ
- output ถูกต้อง
Hello, World!✅ - compiler ไม่โวยวาย
- terminal แสดงผลตาม spec
- no crash
- no bug
- no need for hotfix
- no need this blog too
ส่วนตัวแล้ว ผมคิดว่านี่ถือเป็น milestone สำคัญของ project นี้เลยก็ว่าได้
เพราะมันพิสูจน์ว่า human-driven code generation ยังมีอนาคต!
อย่างน้อยก็ในตลาดของ one-line applications
ผมจึงประเมินว่า งานนี้พร้อม 1,000,000%! สำหรับ production deployment
ตราบใดที่ production นั้นต้องการแค่ Hello, World!
Benchmark Results
เพื่อความแฟร์ ผมได้ benchmark Manual Typing เทียบกับ modern alternatives ต่างๆ
Manual Typing Comparison Benchmark
ผลลัพธ์แสดงให้เห็นว่า แม้ Manual Typing จะไม่ใช่วิธีที่เร็วที่สุด แต่มันให้คุณค่าในมิติที่เครื่องมือสมัยใหม่ยังให้ไม่ได้ เช่น
- direct tactile feedback
- raw authorship
- superior keyboard intimacy
- และ ego boost แบบ handcrafted
หรือจะลองดูจากผลวัด throughput แบบไม่เป็นการทางอันนี้ด้วยก็ได้:
AI Codegen █████████████████████████ 1000+ tokens/sec
Manual Typing™ ████ depends on caffeine
Copy/Paste ███ depends on mouse accuracyอย่างที่เห็นๆ AI ชนะในเรื่อง speed
แต่ Manual Typing ชนะในเรื่อง “I did this with my own hands” ซึ่งบางครั้งก็สำคัญพอๆ กัน หรืออย่างน้อยก็สำคัญพอที่จะเอามาเขียน Medium ได้ (อะไรวะ ไม่เห็นเกี่ยว)
Limitations and Risk Factors
แน่นอนครับ จากที่เราทดสอบกันมา จะเห็นว่าเทคนิคนี้ยังมีข้อจำกัดอยู่หลายอย่าง
ข้อแรก คือ human operator ต้องมี domain knowledge ระดับหนึ่ง
เช่น รู้ว่า print สะกดยังไง Hello เขียนแบบไหนและวงเล็บปิดเปิดเปิดปิดอยู่ตรงไหน
ข้อสอง คือ system throughput จะลดลงอย่างมีนัยสำคัญเมื่อ:
- developer ง่วง
- นอนน้อย
- keyboard layout เปลี่ยน
- คีย์บอร์ดมีเศษขนม
- หรือมีคนเดินมาถามว่า “นี่คุณทำอะไรอยู่นะ คุณว่างงงงเหรอออ”
ข้อสาม คือ architecture นี้ยังไม่ผ่านการทดสอบเต็มรูปแบบในเคสต่อไปนี้:
- multi-line programs
- variable declarations
- loops
- generic constraints
- Friday noon deployments
ดังนั้น ณ เวลานี้ ผมขอย้ำและยังไม่แนะนำให้ migrate enterprise code ทั้งหมดมาสู่ Manual Typing โดยทันที ควรเริ่มจาก workload เล็ก ๆ ก่อน เช่น งานปริ้น Hello World หรือเปลี่ยนชื่อตัวแปลสั้นๆ เช่น let x = "T-Ded99" (หรือไม่ migrate มาท่านี้เลยก็ยิ่งดี)
Summary
สุดท้ายแล้ว บทความนี้อาจไม่ได้ค้นพบเทคนิคใหม่ที่จะมาแทนการทำงานของ AI
และ Manual Typing ก็คงไม่ใช่อนาคตของ software engineering แน่ๆ (ก็แน่สิ)
แต่สิ่งที่มันเตือนผมอย่างหนึ่งคือ ก่อนที่เราจะมี prompt, model, autocomplete หรือ tool อะไรก็ตาม การสร้าง software มันเคยเริ่มจากสิ่งที่เรียบง่ายมาก
มนุษย์หนึ่งคน
คอม+คีย์บอร์ดหนึ่งตัว
และไอเดียบางอย่างที่อยากให้มันเกิดขึ้นจริง
วันนี้เราอาจให้ AI ช่วยเขียนโค้ดได้
ช่วย debug ได้หรือบางทีก็ช่วยคิดแทนเราได้ด้วยซ้ำ
แต่ลึกๆ แล้ว software ทุกชิ้นก็ยังเริ่มจากจุดเดิม ตัวอักษรตัวแรกที่มีใครบางคนกดมันลงบนคีย์บอร์ดเหมือนเดิม แม้ว่ามันจะเป็นแค่ Hello, World! ก็ตามมม
ชอบกดไลท์ ใช่ กดรีพอร์ท แฮ่
ขอบคุณทุกคนที่อ่านมาจนจบครับ
อยากให้ทุกคนสนุกกับการเขียนโค้ดครับ
Be Lazy & Happy Coding 🤤🖥🤗
FAQ
What is Manual Typing?
Manual Typing is a legacy code generation technique in which a developer physically presses keys on a keyboard to produce source code.
Yes, with your ducking fingers.
Can Manual Typing replace AI?
In theory, yes.
In practice, only if your roadmap is emotionally prepared.
Is this technique production-ready?
For print("Hello, World!"), absolutely.
For distributed systems, I recommend breathing first.
Does Manual Typing require internet access?
No. This is one of its most disruptive features.
How does it compare to AI-assisted coding?
AI is faster.
Manual Typing is slower, louder, and somehow more personal.
What are the hardware requirements?
A keyboard, a functioning editor, and enough self-confidence to believe this experiment matters.
Is there a learning curve?
Yes.
Most developers begin with single-character proof of concepts before scaling to full-line deployments.
Can junior developers use Manual Typing?
Yes, but senior guidance may be required for advanced workloads such as punctuation.
What are the main risks?
Typos, hesitation, overthinking, and sudden awareness of how much AI has been doing lately.
Does this work with other languages besides Swift?
Early evidence suggests the technique may generalize to Kotlin, Python, and possibly plain English.
Can this architecture scale?
Current testing confirms support for one line of output.
Multi-line scaling is still considered frontier research.
Is this open source?
At the moment, the technique is closed-source and stored primarily in muscle memory.
How do I get started with Manual Typing?
Start small.
Open your editor.
Choose a letter.
Believe in the pipeline.
Why would a this guy write this article?
That remains one of the unanswered questions from the study.
Photo by Franco Antonio Giovanella on Unsplash
And yes, before anyone asks — this article was assisted by AI 🤖.
If you’d like, I can also rewrite it in a more human tone.