လေ့ကျင့်ခန်း - AI-Generated နှင့် Vibe-Coded App များကို လုံခြုံစွာ Deploy လုပ်ခြင်း

နားလည်ထားရမယ့် အချက်

AI coding assistant တွေဟာ feature တစ်ခု၊ တစ်ခါတလေ app တစ်ခုလုံးကိုတောင် မိနစ်ပိုင်းအတွင်း ဖန်တီးပေးနိုင်ပါတယ်။ ဒီမြန်ဆန်မှုက အမှန်ပါပဲ၊ ဒါပေမယ့် workflow ထဲက risk ရှိရာနေရာကို ရွှေ့ပေးလိုက်ပါတယ် - code ရေးရာကနေ ကိုယ်ရေးမထားတဲ့ code ကို review လုပ်ရာဆီ။

AI-powered app တွေမှာ architecture-specific risk တစ်ခု ထပ်ပေါ်လာပါတယ် - frontend က backend ကို ခေါ်ပြီး backend က AI API (သို့) local model ကို ခေါ်ပါတယ်။ ဒီ service ရဲ့ API key ဟာ browser ဆီ လုံးဝ ရောက်လို့ မရပါဘူး - frontend code ထဲမှာ ထည့်ထားရင် ဘယ်သူမဆို network tab ကနေ ဆွဲထုတ်ပြီး ကိုယ့် account အောက်မှာ အလွဲသုံးစား လုပ်နိုင်ပါတယ်။

Streaming response, အချိန်ကြာမြင့်တဲ့ generation task, request တစ်ခုချင်းစီရဲ့ cost, rate limit - ဒါတွေအားလုံးကို AI feature တစ်ခု production-ready ဖြစ်ခင် ရှင်းလင်းစွာ ကိုင်တွယ်ထားရမယ်၊ live ဖြစ်ပြီးမှ ရှာတွေ့တာ မဟုတ်ပါဘူး။

AI APP DEPLOYMENT ARCHITECTURE
------------------------------
AI APP DEPLOYMENT ARCHITECTURE
-----------------------------------------
  [ User's Browser ]
        |
        v
  [ Frontend (React / Next.js) ]  <-- no AI API key here, ever
        |
        v
  [ Backend / API server ]
        |
        |-- holds the AI API key (server-side env var only)
        |
        +--> [ AI API / local model ]  (OpenAI, Anthropic, etc.)
        |
        +--> [ Managed Database ]
        |
        +--> [ Vector Store ]      (embeddings for RAG)
        |
        +--> [ Object Storage ]    (uploads, generated assets)

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

'chat with your data' feature ထည့်ဖို့ AI assistant ကို သုံးလိုက်တယ်ဆိုပါစို့။ Backend route၊ frontend component၊ database query ကို ဖန်တီးပေးပြီး preview deployment မှာ အားလုံး အလုပ်ဖြစ်နေပါတယ်။ Production မတင်ခင် AI-generated ပြောင်းလဲမှုတိုင်း လိုအပ်တဲ့ review အတိုင်း လိုက်လျှောက်ကြည့်ပါ။

ဒီ check တွေအားလုံး အောင်မြင်မှသာ 'preview မှာ အလုပ်ဖြစ်တယ်' ဆိုတာ app က production traffic အတွက် အသင့်ဖြစ်တယ်လို့ တကယ်ဆိုလိုပါတယ်။

• Preview deployment တစ်ခု အလုပ်ဖြစ်နေတာက app run နေကြောင်း သက်သေပြပေမယ့် secret၊ auth၊ database scope၊ cost အကြောင်းကို တစ်ခုချင်း တိုက်ရိုက်စစ်မှသာ သိနိုင်ပါတယ်။
• AI API key ဟာ server ပေါ်မှာသာ ရှိသင့်တယ် - frontend code (သို့) browser network tab ထဲမှာ တွေ့ရရင် နောက်ဆုံး အလွဲသုံးစားခံရမှာ ဖြစ်ပါတယ်။
• AI-specific deployment risk က code quality ကိစ္စတစ်ခုတည်း မဟုတ်ဘဲ architecture ကိစ္စလည်း ဖြစ်ပါတယ် - streaming, timeout, rate limit, request တစ်ခုချင်းရဲ့ cost အားလုံးကို ရှင်းရှင်းလင်းလင်း ကိုင်တွယ်ရပါမယ်။

AI-Generated App တစ်ခု Deploy မလုပ်ခင်

• AI ရဲ့ summary ကို ကြည့်ရုံသက်သက်မဟုတ်ဘဲ diff တစ်ခုလုံးကို line တစ်ကြောင်းချင်း review လုပ်ပြီးပြီ
• Frontend code ထဲမှာ secret (သို့) API key hardcode ဖြစ်နေတာ (သို့) ပေါက်ကြားနေတာ မရှိပါ
• Route တိုင်းမှာ authentication ဟာ code ထဲမှာ ရှိတာသာမက အမှန်တကယ် enforce ဖြစ်နေပါတယ်
• Database permission တွေက app လိုအပ်တာနဲ့ အတိအကျ scope လုပ်ထားပါတယ်
• Error handling က stack trace (သို့) internal detail တွေကို user ဆီ ပေါက်ကြားစေမှု မရှိပါ
• AI API call တွေအတွက် rate limiting နဲ့ timeout ချိန်ညှိထားပြီးပါပြီ
• Logging ဖွင့်ထားပေမယ့် secret (သို့) user prompt အပြည့်အစုံကို log မချမိပါ
• AI API ရဲ့ cost နဲ့ usage limit ကို နားလည်ပြီး ကန့်သတ်ထားပါတယ်

အတူတူ စမ်းရေးကြည့်မယ်

function reviewGeneratedCode(code) {
  const findings = [];

  const keyPattern = /(sk-[a-zA-Z0-9]{20,}|api[_-]?key\s*[:=]\s*["'][^"']{10,}["'])/i;
  if (keyPattern.test(code)) {
    findings.push("Possible hardcoded API key found in code");
  }

  const callsExternalApi = /fetch\(|axios\.(get|post)/.test(code);
  const hasAuthCheck = /requireAuth|isAuthenticated|checkAuth|session\.user/.test(code);
  if (callsExternalApi && !hasAuthCheck) {
    findings.push("Route calls an external API but has no visible auth check");
  }

  const leaksStack = /res\.(send|json)\(\s*\{?\s*.*err(or)?\.stack/.test(code);
  if (leaksStack) {
    findings.push("Error handler sends the raw stack trace to the client");
  }

  const hasCatch = /catch\s*\(/.test(code);
  if (callsExternalApi && !hasCatch) {
    findings.push("External API call has no error handling");
  }

  const hasTimeout = /timeout|AbortController/i.test(code);
  if (callsExternalApi && !hasTimeout) {
    findings.push("External API call has no timeout configured");
  }

  return findings.length
    ? findings
    : ["No red flags found - safe to proceed to preview deploy"];
}

const riskySnippet = `
const OPENAI_KEY = "sk-abcdefghijklmnopqrstuvwx1234567890";

app.post("/api/chat", async (req, res) => {
  const response = await fetch("https://api.openai.com/v1/chat/completions", {
    headers: { Authorization: \`Bearer \${OPENAI_KEY}\` },
    method: "POST",
    body: JSON.stringify(req.body),
  });
  const data = await response.json();
  res.json(data);
});
`;

const cleanSnippet = `
app.post("/api/chat", requireAuth, async (req, res) => {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), 8000);
  try {
    const response = await fetch("https://api.openai.com/v1/chat/completions", {
      headers: { Authorization: \`Bearer \${process.env.OPENAI_API_KEY}\` },
      method: "POST",
      body: JSON.stringify(req.body),
      signal: controller.signal,
    });
    const data = await response.json();
    res.json(data);
  } catch (err) {
    res.status(500).json({ error: "Something went wrong. Please try again." });
  } finally {
    clearTimeout(timeoutId);
  }
});
`;

console.log("Risky snippet findings:");
console.log(reviewGeneratedCode(riskySnippet));

console.log("\nClean snippet findings:");
console.log(reviewGeneratedCode(cleanSnippet));

reviewGeneratedCode() ကို risky snippet နဲ့ clean snippet နှစ်ခုလုံးအပေါ် run ကြည့်တဲ့အခါ -

Risky snippet findings:
[
  'Possible hardcoded API key found in code',
  'Route calls an external API but has no visible auth check',
  'External API call has no error handling',
  'External API call has no timeout configured'
]

Clean snippet findings:
[ 'No red flags found - safe to proceed to preview deploy' ]

The Twelve-Factor App - Config — Cloud & Deployment

Cloud & Deployment Glossary — အသုံးများသော ဝေါဟာရများ

Production Deployment Checklist