charieswei
/
vibe-coding-cn
mirror of https://github.com/tukuaiai/vibe-coding-cn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix(en): re-translate incomplete files 

- Re-translate Tool Collection.md (5 -> 51 lines)
- Re-translate Glue Coding.md (172 -> 336 lines)
This commit is contained in:
tukuaiai 2025-12-19 03:27:38 +08:00
parent d178f4f8b6
commit 0ad7a87713
2 changed files with 256 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
i18n/en/documents/00-fundamentals/Glue Coding.md
View File

@ -1,19 +1,19 @@
# 🧬 Glue Coding
> **The Holy Grail and Silver Bullet of Software Engineering — finally here.**
> **The holy grail and silver bullet of software engineering – it's finally here.**
---
## 🚀 Disruptive Manifesto
**Glue Coding is not a technology; it's a revolution.**
**Glue Coding is not a technology, but a revolution.**
It might perfectly solve the three fatal flaws of Vibe Coding:
| Pain Points of Traditional Vibe Coding | Solutions of Glue Coding |
| :----------------------------------- | :----------------------- |
| 🎭 **AI Hallucinations** - Generating non-existent APIs, incorrect logic | ✅ **Zero Hallucinations** - Only uses verified mature code |
| 🧩 **Complexity Explosion** - The larger the project, the more out of control | ✅ **Zero Complexity** - Every module is a time-tested wheel |
| Pain Points of Traditional Vibe Coding | Glue Coding's Solution |
|:---|:---|
| 🎭 **AI Hallucinations** - Generating non-existent APIs, incorrect logic | ✅ **Zero Hallucinations** - Only using validated, mature code |
| 🧩 **Complexity Explosion** - The larger the project, the more out of control it becomes | ✅ **Zero Complexity** - Every module is a time-tested wheel |
| 🎓 **High Barrier to Entry** - Requires deep programming skills to master AI | ✅ **Barrier Disappears** - You only need to describe "how to connect" |
---
@ -32,9 +32,9 @@ Glue Coding: AI connects code, humans review connections
- ❌ No longer letting AI generate code from scratch (the source of hallucinations)
- ❌ No longer reinventing the wheel (the source of complexity)
- ❌ No longer requiring you to understand every line of code (the source of high barrier)
- ❌ No longer requiring you to understand every line of code (the source of high barriers)
- ✅ Only reusing mature, production-verified open-source projects
- ✅ Only reusing mature, production-validated open-source projects
- ✅ AI's sole responsibility: understanding your intent and connecting modules
- ✅ Your sole responsibility: clearly describing "what is the input, what is the desired output"
@ -44,12 +44,12 @@ Glue Coding: AI connects code, humans review connections
```
┌─────────────────────────────────────────────────────────┐
│ Your Business Requirements │
│ Your Business Needs │
└─────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ AI Glue Layer │
│ AI Glue Layer │
│ │
│ "I understand what you want to do, let me connect these blocks" │
│ │
@ -58,83 +58,83 @@ Glue Coding: AI connects code, humans review connections
┌────────────────┼────────────────┐
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Mature Module A │ │ Mature Module B │ │ Mature Module C │
│ (100k+ ⭐) │ │ (Production Verified) │ │ (Official SDK) │
│ Mature Module A │ │ Mature Module B │ │ Mature Module C │
│ (100K+ ⭐) │ │ (Production Validated) │ │ (Official SDK) │
└─────────────┘ └─────────────┘ └─────────────┘
```
**Entity**: Mature open-source projects, official SDKs, time-tested libraries
**Link**: AI-generated glue code, responsible for data flow and interface adaptation
**Function**: Your described business goals
**Function**: Your described business objective
---
## 🎯 Why is this a Silver Bullet?
## 🎯 Why is this the Silver Bullet?
### 1. Hallucination Issue → Completely Disappears
### 1. Hallucination Problem → Completely Disappears
AI no longer needs to "invent" anything. It only needs to:
- Read Module A's documentation
- Read Module B's documentation
- Write the data transformation from A to B
**This is what AI excels at, and where it is least likely to make mistakes.**
**This is what AI excels at, and what is least prone to errors.**
### 2. Complexity Issue → Transferred to the Community
### 2. Complexity Problem → Transferred to the Community
Behind each module are:
- Thousands of Issue discussions
- Wisdom of hundreds of contributors
- Years of refinement in production environments
- Hundreds of contributors' wisdom
- Years of production environment refinement
**You are not managing complexity; you are standing on the shoulders of giants.**
**You are not managing complexity, you are standing on the shoulders of giants.**
### 3. Barrier to Entry Issue → Minimized
### 3. Barrier to Entry Problem → Reduced to a Minimum
You don't need to understand:
- Underlying implementation principles
- Details of best practices
- Handling of edge cases
- Best practice details
- Edge case handling
You just need to speak plainly:
> "I want to take Telegram messages, process them with GPT, and save them to PostgreSQL"
You just need to speak human language:
> "I want to process Telegram messages with GPT and save them to PostgreSQL"
**AI will help you find the most suitable wheels and then glue them together.**
---
## 📋 Practical Process
## 📋 Practical Workflow
```
1. Clarify Goal
└─→ "I want to implement XXX functionality"
└─→ "I want to implement XXX function"
2. Find Wheels
└─→ "Are there mature libraries/projects that have done something similar?"
└─→ "Are there any mature libraries/projects that have done something similar?"
└─→ Let AI help you search, evaluate, and recommend
3. Understand Interfaces
└─→ Feed official documentation to AI
└─→ Feed the official documentation to AI
└─→ AI summarizes: what is the input, what is the output
4. Describe Connection
└─→ "Output of A should become input of B"
└─→ "The output of A should become the input of B"
└─→ AI generates glue code
5. Verify Operation
5. Verify Run
└─→ Runs successfully → Done
└─→ Errors → Throw errors to AI, continue gluing
└─→ Error → Give the error to AI, continue gluing
```
---
## 🔥 Classic Case Study
### Case Study: Polymarket Data Analysis Bot
### Case: Polymarket Data Analysis Bot
**Requirement**: Get real-time Polymarket data, analyze it, and push to Telegram
**Requirement**: Real-time acquisition of Polymarket data, analysis, and pushing to Telegram
**Traditional Approach**: Write scraper from scratch, write analysis logic, write Bot → 3000 lines of code, 2 weeks
**Traditional Approach**: Write a crawler from scratch, write analysis logic, write a Bot → 3000 lines of code, 2 weeks
**Glue Approach**:
```
@ -142,16 +142,17 @@ Wheel 1: polymarket-py (Official SDK)
Wheel 2: pandas (Data Analysis)
Wheel 3: python-telegram-bot (Message Push)
Glue code: 50 lines
Development time: 2 hours
Glue Code: 50 lines
Development Time: 2 hours
```
---
## 📚 Further Reading
- [Glue Development Prompt](../../prompts/coding_prompts/glue-development.md)
- [Project Practice: polymarket-dev](../Project%20Practical%20Experience/polymarket-dev/)
- [语言层要素](./语言层要素.md) - 8 Levels of Understanding 100% Code
- [胶水开发提示词](../../prompts/coding_prompts/胶水开发.md)
- [项目实战：polymarket-dev](../项目实战经验/polymarket-dev/)
---
@ -159,14 +160,177 @@ Development time: 2 hours
> **If you can copy, don't write; if you can connect, don't build; if you can reuse, don't originate.**
Glue Coding is the ultimate evolutionary form of Vibe Coding.
Glue Coding is the ultimate evolution of Vibe Coding.
It's not laziness; it's the **highest embodiment of engineering wisdom**—
It's not laziness, but **the highest manifestation of engineering wisdom** –
Leveraging the least amount of original code to drive the greatest productivity.
Using the least amount of original code to leverage the greatest productivity.
**This is the silver bullet software engineering has been waiting 50 years for.**
**This is the silver bullet software engineering has been waiting for for 50 years.**
---
*"The best code is no code at all. The second best is glue code."*
# Glue Coding Methodology
## **1. Definition of Glue Coding**
**Glue coding** is a new software construction method, whose core idea is:
> **Almost entirely reusing mature open-source components, combining them into a complete system with a minimal amount of "glue code".**
It emphasizes "connection" rather than "creation", especially efficient in the AI era.
## **2. Background**
Traditional software engineering often requires developers to:
* Design architecture
* Write logic themselves
* Manually handle various details
* Reinvent the wheel
This leads to high development costs, long cycles, and low success rates.
However, the current ecosystem has fundamentally changed:
* Thousands of mature open-source libraries on GitHub
* Frameworks covering various scenarios (Web, AI, Distributed, Model Inference...)
* GPT / Grok can help search, analyze, and combine these projects
In this environment, writing code from scratch is no longer the most efficient way.
Thus, "glue coding" has emerged as a new paradigm.
## **3. Core Principles of Glue Coding**
### **3.1 Don't write what can be avoided, write as little as possible**
Any functionality with a mature existing implementation should not be reinvented.
### **3.2 Copy-paste whenever possible**
Directly copying and using community-validated code is a normal engineering process, not laziness.
### **3.3 Stand on the shoulders of giants, don't try to be a giant**
Utilize existing frameworks instead of trying to write a "better wheel" yourself.
### **3.4 Do not modify original repository code**
All open-source libraries should ideally remain immutable, used as black boxes.
### **3.5 The less custom code, the better**
Your written code only serves to:
* Combine
* Call
* Encapsulate
* Adapt
Which is the so-called **glue layer**.
## **4. Standard Workflow of Glue Coding**
### **4.1 Clarify Requirements**
Break down the system's functionality into individual requirements.
### **4.2 Use GPT/Grok to Deconstruct Requirements**
Let AI refine requirements into reusable modules, capabilities, and corresponding subtasks.
### **4.3 Search for Existing Open-Source Implementations**
Leverage GPT's internet capabilities (e.g., Grok):
* Search for corresponding GitHub repositories for each sub-requirement.
* Check for reusable components.
* Compare quality, implementation methods, licenses, etc.
### **4.4 Download and Organize Repositories**
Pull the selected repositories locally and organize them by category.
### **4.5 Organize According to Architectural System**
Place these repositories into the project structure, for example:
```
/services
/libs
/third_party
/glue
```
And emphasize: **Open-source repositories are third-party dependencies and must never be modified.**
### **4.6 Write Glue Layer Code**
The role of glue code includes:
* Encapsulating interfaces
* Unifying input/output
* Connecting different components
* Implementing minimal business logic
The final system is composed of multiple mature modules.
## **5. Value of Glue Coding**
### **5.1 Extremely High Success Rate**
Because it uses community-validated mature code.
### **5.2 Extremely Fast Development Speed**
A large amount of functionality can be directly reused.
### **5.3 Reduced Costs**
Time cost, maintenance cost, and learning cost are all significantly reduced.
### **5.4 More Stable System**
Relies on mature frameworks rather than individual implementations.
### **5.5 Easy to Extend**
Capabilities can be easily upgraded by replacing components.
### **5.6 Strong Synergy with AI**
GPT can assist in searching, deconstructing, and integrating, making it a natural enhancer for glue engineering.
## **6. Glue Coding vs. Traditional Development**
| Project | Traditional Development | Glue Coding |
| ----------- | ------------------------ | ------------- |
| Feature Implementation | Write yourself | Reuse open-source |
| Workload | Large | Much smaller |
| Success Rate | Uncertain | High |
| Speed | Slow | Extremely fast |
| Error Rate | Prone to pitfalls | Uses mature solutions |
| Focus | "Building wheels" | "Combining wheels" |
## **7. Typical Application Scenarios for Glue Coding**
* Rapid prototype development
* Small teams building large systems
* AI application/model inference platforms
* Data processing pipelines
* Internal tool development
* System Integration
## **8. Future: Glue Engineering will become the new mainstream programming method**
As AI capabilities continue to strengthen, future developers will no longer need to write a lot of code themselves, but rather:
* Find wheels
* Combine wheels
* Intelligently connect components
* Build complex systems at extremely low cost
Glue coding will become the new standard for software productivity.

52
i18n/en/documents/04-resources/Tool Collection.md
View File

@ -1,5 +1,51 @@
IDE and plugins; VSCode, Windsurf (free use), Shandiashuo (for output), Continue - open-source AI code agent, Local History, Partial Diff
# 🛠️ Toolset
Models; Codex, Gemini, KimiK2, Grok
> Vibe Coding Common Tools Quick Reference
Websites; https://aistudio.google.com/; https://zread.ai/; https://chatgpt.com/; https://github.com; https://www.bilibili.com; https://www.mermaidchart.com/app/dashboard; https://notebooklm.google.com/; https://z-lib.fm/; https://docs.google.com/spreadsheets/u/0/; https://script.google.com/home?pli=1
## 💻 IDEs and Plugins
| Tool | Description |
|:---|:---|
| [VS Code](https://code.visualstudio.com/) | Mainstream editor |
| [Windsurf](https://windsurf.com/) | AI IDE, free quota for new users |
| [Cursor](https://cursor.com/) | AI-native editor |
| [Continue](https://continue.dev/) | Open-source AI code assistant plugin |
| Local History | VS Code local history plugin |
| Partial Diff | VS Code diff viewer plugin |
## 🤖 AI Models
| Model | Description |
|:---|:---|
| Claude Opus 4.5 | Strong coding capabilities |
| GPT-5.1 Codex | Complex logic processing |
| Gemini 2.5 Pro | Free long context |
## ⌨️ CLI Tools
| Tool | Description |
|:---|:---|
| [Kiro](https://kiro.dev/) | AWS official, free Claude Opus |
| [Droid](https://factory.ai/) | Multi-model CLI access |
| Claude Code | Anthropic official CLI |
| Codex CLI | OpenAI official CLI |
| Gemini CLI | Google official CLI, free |
## 🌐 Common Websites
| Website | Purpose |
|:---|:---|
| [AI Studio](https://aistudio.google.com/) | Google free Gemini |
| [ChatGPT](https://chatgpt.com/) | OpenAI conversation |
| [Zread](https://zread.ai/) | AI repository reading |
| [GitHub](https://github.com/) | Code hosting |
| [Mermaid Chart](https://www.mermaidchart.com/) | Text to diagram |
| [NotebookLM](https://notebooklm.google.com/) | AI note-taking tool |
| [Google Sheets](https://docs.google.com/spreadsheets/) | Online spreadsheets |
| [Apps Script](https://script.google.com/) | Google scripts |
| [Z-Library](https://z-lib.fm/) | E-book resources |
| [Bilibili](https://www.bilibili.com/) | Video tutorials |
## 🔗 More Resources
See [External Resources Aggregation](./外部资源聚合.md)