Bridge to Topic 5: AI-Powered E-Commerce Golang — Preview and Preparation

 1TOPIC 4 — AI-ASSISTED DEVOPS (done):
 2
 3PART 1 — Foundation:
 4  ✅ Article 01: Why AI in the pipeline
 5  ✅ Article 02: The 4-layer pipeline architecture
 6  ✅ Article 03: Setting up Claude in GitHub Actions
 7  ✅ Article 04: Spec validation in CI
 8
 9PART 2 — Quality Gates:
10  ✅ Article 05: Automated code review
11  ✅ Article 06: Automated security audit
12  ✅ Article 07: Test coverage enforcement
13  ✅ Article 08: Architecture linting
14  ✅ Article 09: Branch protection + quality gate
15
16PART 3 — Automation:
17  ✅ Article 10: Auto PR description
18  ✅ Article 11: Auto changelog + release notes
19  ✅ Article 12: Migration validation
20  ✅ Article 13: Multi-environment deployment
21  ✅ Article 14: Auto rollback
22
23PART 4 — LLMOps Lite:
24  ✅ Article 15: Prompt version control
25  ✅ Article 16: AI feature flags
26  ✅ Article 17: Cost monitoring
27  ✅ Article 18: AI incident playbook
28  ✅ Article 19: Complete pipeline integration
29  ✅ Article 20: Bridge to Topic 5 (this article)
30
31TOTAL: 20 articles, ~22,000 lines of content

 1BEFORE Topic 4 (baseline):
 2  Code Review: 1-2 days, 8 mechanical comments/PR
 3  Spec compliance: manual, depends on the reviewer
 4  Security: gosec one-off, not continuous
 5  Deployment: manual, without a health check
 6  AI features: none
 7
 8AFTER Topic 4 (month 4):
 9  Code Review: 4 hours, 1.8 mechanical comments/PR (-78%)
10  Spec compliance: automated, every PR
11  Security: continuous, layered (gitleaks → gosec → govulncheck → AI)
12  Deployment: progressive canary, auto-rollback
13  AI features: feature-flagged, monitored, with an incident playbook
14
15The engineering team now:
16  - Ships 40% faster
17  - With 80% fewer production bugs
18  - With reliable AI features (99.5% uptime)
19  - With controlled cost ($12/month pipeline cost)

 1Topic 5 will build AI-powered features that need:
 2
 3Infrastructure (already exists from Topic 4):
 4  ✅ Claude API integration pattern
 5  ✅ Feature flag system (gradual rollout)
 6  ✅ Cost monitoring + budget enforcement
 7  ✅ Prompt version control + evaluation
 8  ✅ Incident detection + playbook
 9  ✅ Quality gates for AI code
10
11Patterns already established:
12  ✅ AI call with fallback
13  ✅ Circuit breaker for AI services
14  ✅ Canary rollout for AI features
15  ✅ Quality sampling for AI output
16  ✅ Budget guard before every AI call
17
18Without Topic 4's infrastructure:
19  → AI features built without monitoring
20  → Cost spikes go undetected
21  → Quality degradation goes unknown
22  → Incidents without a playbook
23
24WITH Topic 4's infrastructure:
25  → Ship AI features with confidence
26  → Know exactly what each feature costs
27  → Detect quality issues automatically
28  → Respond to incidents systematically

 15 major AI features that will be built in Topic 5:
 2
 31. AI PRODUCT RECOMMENDATION
 4   Input: user browsing history, current cart
 5   Output: personalized product recommendations
 6   Tech: Claude + embedding-based similarity
 7   Target: +15% cart conversion rate
 8
 92. AI SEMANTIC SEARCH
10   Input: natural language query ("cheap blue wedding outfit")
11   Output: relevant products without an exact keyword match
12   Tech: Claude embeddings + vector search
13   Target: -30% "no results found" rate
14
153. AI PRODUCT DESCRIPTION
16   Input: product SKU, attributes, photos
17   Output: compelling product description in Bahasa Indonesia
18   Tech: Claude haiku with multimodal support
19   Target: -80% time to publish a new product
20
214. AI CUSTOMER SERVICE
22   Input: customer question via chat
23   Output: instant answer or escalation to a human
24   Tech: Claude with RAG (product catalog + FAQ)
25   Target: 70% of questions resolved without a human
26
275. AI DYNAMIC PRICING
28   Input: demand signals, inventory level, competitor prices
29   Output: optimized price suggestion
30   Tech: Claude with structured output
31   Target: +5% gross margin

 1// Pattern that will be used in Topic 5
 2// Already established in Topic 4
 3
 4// 1. AI Call with Fallback (Article 18 pattern)
 5type ProductRecommender struct {
 6    aiClient  ai.Client
 7    fallback  *RuleBasedRecommender
 8    flags     feature.Manager
 9    tracker   *cost.Tracker
10}
11
12func (r *ProductRecommender) Recommend(ctx context.Context, userID string) ([]Product, error) {
13    // Feature flag check (Article 16)
14    if !r.flags.IsEnabledForUser(ctx, feature.AIRecommendation, userID) {
15        return r.fallback.Recommend(ctx, userID)
16    }
17
18    // Budget check (Article 17)
19    if err := r.tracker.WithBudget("ai-recommendation", estimatedCost); err != nil {
20        return r.fallback.Recommend(ctx, userID)
21    }
22
23    // AI call with circuit breaker (Article 18)
24    result, err := r.aiRecommend(ctx, userID)
25    if err != nil {
26        // Graceful fallback
27        return r.fallback.Recommend(ctx, userID)
28    }
29
30    return result, nil
31}

 1# .specify/features/ai-product-recommendation/prompt-v1.0.md
 2---
 3name: product-recommendation
 4version: 1.0
 5model: claude-haiku-4-5-20251001
 6max_tokens: 800
 7tags: [production, recommendation]
 8---
 9
10You are the AI recommendation engine for Santekno Shop.
11
12User Context:
13- User ID: {{.UserID}}
14- Frequently viewed categories: {{.FrequentCategories}}
15- Items in cart: {{.CartItems}}
16- Budget range: Rp {{.MinBudget}} - Rp {{.MaxBudget}}
17
18Available products (sample):
19{{range .AvailableProducts}}
20- {{.Name}} | Rp {{.Price}} | Stock: {{.Stock}} | Category: {{.Category}}
21{{end}}
22
23Recommend the 5 most relevant products.
24Priority: relevance > popularity > margin.
25
26Output JSON:
27{
28  "recommendations": [
29    {
30      "product_id": "uuid",
31      "reason": "brief reason in Bahasa Indonesia",
32      "confidence": 0.85
33    }
34  ]
35}

 1-- Tables to track AI interactions (Topic 5 will use these)
 2
 3-- User embedding for personalization
 4CREATE TABLE user_embeddings (
 5    user_id UUID PRIMARY KEY REFERENCES users(id),
 6    embedding VECTOR(1536),  -- OpenAI ada-002 dimension
 7    updated_at TIMESTAMPTZ DEFAULT NOW()
 8);
 9
10-- Product embedding for semantic search
11CREATE TABLE product_embeddings (
12    product_id UUID PRIMARY KEY REFERENCES products(id),
13    embedding VECTOR(1536),
14    updated_at TIMESTAMPTZ DEFAULT NOW()
15);
16
17-- AI interaction log for quality monitoring (Article 18 pattern)
18CREATE TABLE ai_interactions (
19    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
20    feature VARCHAR(100) NOT NULL,
21    user_id UUID REFERENCES users(id),
22    input_hash VARCHAR(64),  -- hash of the input, not raw PII
23    output_quality_score NUMERIC(3,1),  -- 0-100, from sampling
24    model VARCHAR(100),
25    input_tokens INT,
26    output_tokens INT,
27    cost_usd NUMERIC(10,6),
28    created_at TIMESTAMPTZ DEFAULT NOW()
29);
30
31-- Prompt performance tracking (Article 15 pattern)
32CREATE TABLE prompt_performance (
33    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
34    prompt_name VARCHAR(100) NOT NULL,
35    prompt_version VARCHAR(20) NOT NULL,
36    pass_rate NUMERIC(5,2),  -- from evaluation
37    avg_quality_score NUMERIC(5,2),
38    sample_count INT,
39    created_at TIMESTAMPTZ DEFAULT NOW()
40);

 1// Preview: vector search for semantic product search
 2// Will be implemented in Topic 5
 3
 4package search
 5
 6import (
 7    "context"
 8    "github.com/pgvector/pgvector-go"
 9)
10
11type SemanticSearchService struct {
12    db        *pgxpool.Pool
13    embedder  *EmbeddingClient  // Claude or OpenAI embedding API
14}
15
16func (s *SemanticSearchService) Search(ctx context.Context, query string) ([]Product, error) {
17    // 1. Convert query into an embedding vector
18    queryEmbedding, err := s.embedder.Embed(ctx, query)
19    if err != nil {
20        // Fallback to full-text search
21        return s.fullTextSearch(ctx, query)
22    }
23
24    // 2. Search for similar products in the database
25    rows, err := s.db.Query(ctx, `
26        SELECT id, name, price, description,
27               1 - (embedding <=> $1) AS similarity
28        FROM products
29        WHERE 1 - (embedding <=> $1) > 0.7
30        ORDER BY embedding <=> $1
31        LIMIT 20
32    `, pgvector.NewVector(queryEmbedding))
33
34    // 3. Return ranked results
35    // ...
36}

 1// Preview: Retrieval-Augmented Generation for customer service
 2// Pattern that will be used in Topic 5
 3
 4type CustomerServiceBot struct {
 5    claude     *anthropic.Client
 6    retriever  *FAQRetriever
 7    flags      feature.Manager
 8}
 9
10func (b *CustomerServiceBot) Answer(ctx context.Context, question string) (string, error) {
11    // 1. Retrieve relevant FAQs and product info
12    context, err := b.retriever.Retrieve(ctx, question, 5)
13    if err != nil { return b.defaultAnswer(question), nil }
14
15    // 2. Generate the answer with Claude + context
16    prompt := fmt.Sprintf(`You are the customer service for Santekno Shop.
17
18Context from the knowledge base:
19%s
20
21Customer question: %s
22
23Answer politely in Bahasa Indonesia.
24If you don't know, direct them to the human support team.`, context, question)
25
26    // 3. Return the AI-generated answer
27    return b.claude.Complete(ctx, prompt)
28}

 1Cost estimate for production AI features in Topic 5:
 2
 31. Product Recommendation:
 4   100,000 MAU × 10 recommendations/session = 1M requests/month
 5   Avg: 800 input + 200 output tokens
 6   Cost/request: (800×$0.80 + 200×$4.00) / 1M = $0.0014
 7   Monthly: 1M × $0.0014 = $1,400/month
 8
 9   Optimization: cache recommendations per user (TTL: 1 hour)
10   Cache hit rate ~70%: effective cost = $420/month
11
122. Semantic Search:
13   500,000 searches/month
14   Embedding only: $0.0001/request (ada-002)
15   Monthly: 500K × $0.0001 = $50/month
16
173. Product Description:
18   1,000 new products/month
19   One-time generation per product
20   Avg: 500 input + 300 output = $0.0016/product
21   Monthly: 1K × $0.0016 = $1.60/month (one-time cost!)
22
234. Customer Service:
24   50,000 questions/month, 30% resolved by AI
25   Avg: 2,000 input + 500 output = $0.0036/request
26   Monthly: 15K × $0.0036 = $54/month
27
285. Dynamic Pricing:
29   10,000 price calculations/month
30   Avg: 1,000 input + 200 output = $0.0016/request
31   Monthly: 10K × $0.0016 = $16/month
32
33TOTAL ESTIMATED (Topic 5 features): ~$540/month
34(vs pipeline cost $12/month from Topic 4)

 1TOPIC 4: AI FOR DEVELOPERS (internal tooling)
 2  → Prompt improves developer productivity
 3  → Output: PR descriptions, changelogs, review comments
 4  → User: software developer
 5  → Volume: 100-500 requests/day
 6  → Cost tolerance: low ($10-20/month)
 7  → Quality: "good enough" (developers can evaluate it)
 8
 9TOPIC 5: AI FOR USERS (product features)
10  → Prompt produces user-facing output
11  → Output: product recommendations, search results, answers
12  → User: end customer (non-technical)
13  → Volume: 100,000-1,000,000 requests/day
14  → Cost tolerance: medium ($500-1000/month max)
15  → Quality: critically important (directly affects conversion rate)
16
17Implications:
18  Topic 5 needs stricter evaluation
19  Topic 5 needs more aggressive cost optimization
20  Topic 5 needs more sophisticated monitoring
21  Topic 5 needs more rigorous A/B testing

 1Tools from Topic 4 used directly in Topic 5:
 2
 3internal/ai/prompt/ → same registry, now for product features
 4internal/ai/cost/   → same tracker, now tracking product costs
 5internal/feature/   → same flags, now for product features
 6internal/ai/monitor/ → same quality monitor, now for product output
 7
 8What's NEW in Topic 5:
 9  internal/ai/embedding/  → vector embedding management
10  internal/ai/rag/        → retrieval-augmented generation
11  internal/ai/evaluation/ → automated quality scoring for user-facing output
12  internal/recommendation/ → business logic for AI recommendations

 1Checklist before continuing to Topic 5:
 2
 3From Topic 4 (must already exist):
 4□ A comprehensive CLAUDE.md
 5□ Feature flag system running
 6□ Cost monitoring configured
 7□ Prompt version control set up
 8□ Incident playbook exists and is tested
 9□ CI pipeline with all gates
10□ Branch protection configured
11
12Additions for Topic 5:
13□ pgvector extension in PostgreSQL
14□ Vector search index set up
15□ Embedding model access (OpenAI or Voyage)
16□ Budget approval for $500-1000/month AI cost
17□ A/B test infrastructure
18□ User analytics tracking (to evaluate recommendation quality)
19
20Team readiness:
21□ At least 1 developer familiar with vector search
22□ At least 1 developer who can evaluate AI output quality
23□ A product manager involved in metric definition

 1TOPIC 5: AI-POWERED E-COMMERCE GO APPLICATIONS
 2
 3Part 1 (Articles 1-5): Foundation AI Features
 4  Article 01: AI-powered e-commerce architecture
 5  Article 02: Embedding and vector search
 6  Article 03: RAG for product knowledge
 7  Article 04: Semantic search implementation
 8  Article 05: AI product description generator
 9
10Part 2 (Articles 6-10): Personalization
11  Article 06: User preference modeling
12  Article 07: AI product recommendation
13  Article 08: Personalized search ranking
14  Article 09: A/B testing AI features
15  Article 10: Recommendation performance analysis
16
17Part 3 (Articles 11-15): Customer Experience
18  Article 11: AI customer service bot
19  Article 12: Sentiment analysis from reviews
20  Article 13: Intelligent FAQ system
21  Article 14: Multi-turn conversation
22  Article 15: Human escalation detection
23
24Part 4 (Articles 16-20): Business Intelligence
25  Article 16: AI dynamic pricing
26  Article 17: Demand forecasting
27  Article 18: Fraud detection with AI
28  Article 19: Business dashboard AI insights
29  Article 20: Scaling AI features

 1Skills needed in Topic 5 that haven't been covered:
 2
 31. Vector Embeddings:
 4   What: representing text semantics as a vector
 5   Why: semantic search, similarity matching
 6   Tool: OpenAI text-embedding-ada-002 or Voyage AI
 7
 82. Vector Database:
 9   What: a database optimized for similarity search
10   Why: efficient nearest-neighbor search over millions of vectors
11   Tool: pgvector (PostgreSQL extension) or Pinecone
12
133. RAG (Retrieval-Augmented Generation):
14   What: AI enriched with retrieved context
15   Why: factual, up-to-date answers without hallucination
16   Pattern: query → retrieve relevant docs → generate answer
17
184. Evaluation for User-Facing AI:
19   What: metrics to measure user-facing AI quality
20   Why: recommendation CTR, search relevance, answer accuracy
21   Method: A/B testing, human evaluation, automated metrics
22
23All of these will be covered in Topic 5.

 1# Install pgvector for PostgreSQL
 2psql -c "CREATE EXTENSION IF NOT EXISTS vector;"
 3
 4# Install the Go packages that will be needed
 5go get github.com/pgvector/pgvector-go
 6go get github.com/sashabaranov/go-openai  # for embedding
 7
 8# Test embedding API access
 9curl https://api.openai.com/v1/embeddings \
10  -H "Authorization: Bearer $OPENAI_API_KEY" \
11  -H "Content-Type: application/json" \
12  -d '{"input": "running shoes", "model": "text-embedding-ada-002"}'
13
14# Create the necessary tables (from Article 20.07)
15psql -f scripts/create-vector-tables.sql
16
17# Verify the environment is ready
18go run ./cmd/verify-topik5-prereqs/main.go
19# Expected output: All prerequisites satisfied ✅

 1From the Topic 4 experience, these are the anti-patterns
 2NOT to repeat in Topic 5:
 3
 4AP1: "AI without fallback"
 5  → Every AI call MUST have a non-AI fallback
 6  → Users must never get an error because the AI is down
 7
 8AP2: "Ship an AI feature without monitoring"
 9  → Every feature needs a cost metric, quality sampling, error rate
10  → Without monitoring = flying blind
11
12AP3: "Roll out 100% immediately"
13  → All AI features start at 5% of users
14  → Gradual rollout = controlled experiment
15
16AP4: "Prompt without test cases"
17  → Every prompt needs evaluation test cases
18  → Without tests = you don't know when quality drops
19
20AP5: "Cost without budget"
21  → Every feature needs an explicit budget
22  → Without a budget = billing surprise
23
24AP6: "AI feature without a kill switch"
25  → Every feature needs instant disable capability
26  → Kill switch = safety net

 1Top 10 lessons from building an AI-assisted DevOps pipeline:
 2
 31. Start with WHY, not HOW
 4   Business case first, tooling later
 5
 62. Graduated enforcement is critical
 7   Never start strict — build trust gradually
 8
 93. Graceful degradation above all
10   AI failure should never cause a user-facing error
11
124. Cost is an engineering metric, not finance
13   Monitor cost like you monitor latency
14
155. Prompts are code — version them
16   Unversioned prompts = technical debt
17
186. Evaluation before deployment
19   No prompt change without test case validation
20
217. Feature flags are safety nets
22   Deploy code without enabling features
23
248. Incidents will happen — prepare playbooks
25   Documentation written before the incident is too late
26
279. Pipeline is team agreement in code
28   Frame as guardrails, not surveillance
29
3010. Measure everything, decide by data
31    Scorecard monthly, adjust based on the numbers

 1Dear Santekno Engineering Team,
 2
 3Topic 4 is about one thing: confidence.
 4
 5Confidence to ship faster, because the pipeline catches issues automatically.
 6Confidence to deploy to production, because there's canary + auto-rollback.
 7Confidence to build AI features, because there's LLMOps infrastructure.
 8Confidence to measure improvement, because there's a scorecard.
 9
10The journey from "ship and pray" to "ship with confidence" requires
11investment. 20 articles, 4 sprints, ~$12/month. But the return:
12
13  - 40% faster delivery
14  - 80% fewer production bugs
15  - Reliable AI features
16  - A more satisfied team
17
18Now, with this solid foundation, we're ready for Topic 5:
19building AI features that directly transform the customer experience.
20
21Let's build something great.
22
23— Santekno Engineering Team