Forem: kk mors

Building an AI Interactive Story Game with Hidden Game Mechanics

kk mors — Fri, 15 May 2026 11:33:02 +0000

What Makes an AI Story Game Feel Real?

Most AI chatbots just respond. But an interactive story game needs secrets — things the player doesn't know that the AI works around. That's the technical challenge I want to share today.

I built BiasSecret, an AI-powered interactive romance story game. The twist? Every playthrough randomly generates hidden parameters that the AI narrator knows about but the player has to discover through gameplay.

Here's how the architecture works under the hood.

The Hidden State Architecture

The core insight: an LLM can simulate hidden game mechanics, but it needs to know the secrets while understanding it must never reveal them.

Generation of Hidden Parameters

AFFECTION_TYPES = [
"True love: he genuinely loves you, feelings are deep and real",
"Mutual need: you both need this relationship for some comfort or benefit",
"Transactional: this relationship helps both your careers or social standing",
"Emotional dependence: he depends on your emotional support",
"Impulse: it started as a rash decision, he's unsure whether to continue",
]

HIDDEN_PERSONALITIES = [
"Player: he's seeing multiple people simultaneously",
"Commitment-phobe: not serious about relationships",
"Avoidant attachment: pulls away when relationship deepens",
"Workaholic: career always comes before your relationship",
"People-pleaser: too nice to everyone",
"Controlling: wants to control every aspect of your life",
"Emotional: mood swings are unpredictable",
]

Each new game gets a random combination — that's over 245 unique game states from just 3 parameter groups. The AI then weaves a narrative around these constraints without stating them directly.

Injecting Secrets Into the System Prompt

def build_system_prompt(session):
    prompt = get_prompt(session.language or "zh")
    prompt = prompt.replace("[IDENTITY]", session.user_identity)
    prompt = prompt.replace("[STAR_NAME]", session.star_name)
    prompt = prompt.replace("[NICKNAME]", session.nickname)

    # Add hidden parameters as invisible instructions
    hidden = (
        f"\n\n## Hidden Settings (AI only — NEVER reveal to user)\n"
        f"Hidden feelings: {session.hidden_affection}\n"
        f"Hidden personality: {session.hidden_personality}\n"
        f"Reason for secrecy: {session.secret_reason}\n"
        f"Note: Start subtly hinting at hidden personality through story clues after Round 20."
    )
    prompt += hidden
    return prompt

The ## Hidden Settings block tells the AI the full truth about this playthrough. The LLM's inherent instruction-following prevents it from spilling secrets — but its narrative generation naturally leaks clues through dialogue and events.

Enforcing Turn-by-Turn Progression

One challenge with LLM-driven games: the AI wants to be a passive storyteller. You have to force it to maintain forward momentum. The system prompt includes explicit time/place progression rules:

Each turn advances time by 2-6 hours. Every 3-5 turns moves to the next day. Location must change each turn.

This prevents the "stuck in the same coffee shop" problem that kills immersion.

API Integration Pattern: DeepSeek

The game uses DeepSeek's API for generation. The integration pattern is straightforward:

async def call_deepseek(system_prompt, history_text, current_turn=0, language="zh"):
    messages = [
        {"role": "system", "content": system_prompt},
    ]

    if not history_text or "not started yet" in history_text:
        # First turn needs extra context
        user_content = (
            f"Game starts! The user's identity is {identity}, "
            f"the idol is {star}. This is Round {next_turn}, "
            f"time is a weekday morning. Generate narration and choices."
        )
    else:
        user_content = history_text

    messages.append({"role": "user", "content": user_content})

    async with httpx.AsyncClient(timeout=60) as client:
        response = await client.post(
            f"{BASE_URL}/v1/chat/completions",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={
                "model": "deepseek-chat",
                "messages": messages,
                "temperature": 0.9,
                "max_tokens": 2000,
            },
        )
        data = response.json()
        return data["choices"][0]["message"]["content"]

Key parameters for narrative games:

temperature: 0.9 — High creativity for variety
max_tokens: 2000 — Room for rich narration + player choices
60s timeout — DeepSeek can be slower on long histories

The Viral Growth Loop: Invite-to-Unlock

Instead of a pure paywall, the game uses a viral invite system:

FREE_TURN_LIMIT = 30     # Free users get 30 rounds of gameplay
BONUS_AT_1 = 10          # +10 rounds for 1 invite
BONUS_AT_3 = 30          # +30 rounds for 3 invites
BONUS_AT_5 = 999         # 5 invites = unlimited play

This creates a natural funnel:

Player gets invested in the story (first 30 rounds = ~15-20 minutes of gameplay)
To continue, they share a unique invite link
Each invited player who signs up unlocks more rounds
At 5 invites, the game is fully unlocked

For a niche audience (K-pop fans who are highly engaged on social media), this is far more effective than a paywall. The invite-to-unlock model leverages existing community dynamics — fans naturally share with fellow fans on Twitter, Discord, and Weverse.

Tech Stack Summary

Layer	Technology
Backend	FastAPI + SQLAlchemy
AI Model	DeepSeek API
Frontend	Next.js 15 + React 19
Styling	Tailwind CSS v4
Database	SQLite (PostgreSQL-ready schema)
Deployment	systemd + Nginx
Growth	Invite-to-unlock viral loop

What I Learned

1. Hidden state is more engaging than fixed stories.
Every playthrough feels unique because the hidden parameters create different dynamics. Players compare notes about what "type" of story they got.

2. LLMs are surprisingly good at hinting.
Without explicit "sneak in a clue" instructions, the AI naturally writes dialogue and events that reflect the hidden state. A workaholic cancels dates. A player has a suspicious phone message.

3. Turn-based progression rules are non-negotiable.
Without forced time/location advancement in the system prompt, the AI will happily narrate the same scene forever. Explicit rules are essential for game-like pacing.

4. The invite loop works for niche communities.
K-pop fans are naturally networked. An invite-to-unlock mechanic that leverages existing social graphs beats paid acquisition for this demographic.

Try It Yourself

If you're curious about AI-powered interactive storytelling, check out BiasSecret — an AI K-pop secret dating simulator built with this architecture.

And if you're building something similar — especially hidden-state LLM games — I'd love to hear about your approach in the comments!

The 3,000-Year-Old Algorithm That Powers Modern AI Fortune Telling

kk mors — Sat, 09 May 2026 04:12:26 +0000

BaZi is not mysticism — it's an algorithm.

When most Westerners hear "Chinese fortune telling," they picture incense, turtle shells, and a mysterious old man. But BaZi (八字, "Eight Characters") is different. It's a deterministic, rules-based system that's been refined over 3,000 years — and modern AI is proving to be its perfect interpreter.

Here's how it works, why AI excels at it, and how you can calculate someone's destiny in 50 lines of Python.

The Algorithm: Your Birth Date → 8 Characters

BaZi distills your birth year, month, day, and hour into four pillars. Each pillar has a Heavenly Stem (天干) and an Earthly Branch (地支). Together, that's 8 characters — hence the name.

The mapping isn't arbitrary. It uses:

The 10 Heavenly Stems (五行 elements × Yin/Yang)
The 12 Earthly Branches (zodiac animals)
The Sexagenary cycle: a 60-unit calendar system running since 2637 BCE

The "magic" is in the interactions: each element generates or controls others (Wood feeds Fire, Water controls Fire, etc.). Your chart's balance of elements reveals your personality, career tendencies, and life patterns.

Calculating It in Python

The hardest part? Converting a Gregorian date to the Chinese lunar calendar. The solar terms add complexity — a "month" begins at a specific solar longitude, not on the 1st.

lunar-python handles all of this:

from lunar_python import Solar

solar = Solar.fromYmdHms(1988, 12, 30, 12, 0, 0)
lunar = solar.getLunar()
bazi = lunar.getEightChar()

print(f"Year:  {bazi.getYear()}")      # 戊辰
print(f"Month: {bazi.getMonth()}")      # 甲子
print(f"Day:   {bazi.getDay()}")        # 己
print(f"Hour:  {bazi.getTime()}")       # 庚午
print(f"Day Master: {bazi.getDay()}")   # 己 (Earth)

The Day Master (日主) is the chart's center — it represents "you." Everything else is interpreted relative to this element.

Hidden Data in Each Pillar

Each pillar contains more than just its stem and branch. The Hidden Stems (藏干) add layers of element influence:

print(f"Year hidden stems:  {bazi.getYearHideGan()}")   # 戊, 乙, 癸
print(f"Month hidden stems:  {bazi.getMonthHideGan()}")  # 甲
print(f"Day hidden stems:    {bazi.getDayHideGan()}")    # 己, 丁, 乙

The Ten Gods (十神) mapping each element's relationship to your Day Master reveals career inclinations, wealth potential, and relationship patterns.

Why AI is Surprisingly Good at This

Here's the key insight: BaZi maps perfectly to what LLMs do best.

1. Pattern matching across large reference tables — The 60 pillars, element cycles, Ten Gods... combinatorial lookup. LLMs excel at it.

2. Context-aware text generation — A human astrologer synthesizes dozens of interacting factors. AI juggles element balance, seasonal strength, clash/compatibility, and luck cycles simultaneously.

3. Cultural knowledge baked in — Models already "understand" the metaphors (Water = wisdom, Fire = passion, Earth = stability).

4. No cold reading — AI generates readings purely from the chart's mathematical structure. No guessing, no leading questions.

The result? AI-generated BaZi readings can be surprisingly insightful — not because the AI has mystical powers, but because it's processing a rigorous symbolic system at scale.

What I Built

I turned this into SoulChart — a web app that:

Takes your birth date/time (no email or account required)
Calculates your full BaZi chart with Python
Generates a personalized reading via DeepSeek AI
Shows a free preview — unlock the full report for $3.99

The free preview shows your Day Master personality. The full reading covers career, relationships, current-year luck, and life advice across 6 sections.

The Bigger Picture

Every ancient knowledge system is a compressed dataset. BaZi encodes centuries of observed human patterns into a symbolic grammar. Tarot, I Ching, Western astrology — same principle, different encoding.

AI is the first technology that can truly "decompress" these systems. Not by proving them right or wrong — but by applying their logic consistently and exhaustively.

BaZi's element theory has interesting parallels with modern personality frameworks like the Big Five — both describe tendencies on spectrums rather than fixed types. The ancient Chinese weren't "superstitious" — they were building classification systems with the best tools they had.

Try It

soulchart.cc — Enter your birth date, get a free reading
The calculation engine is open-source (lunar-python library)
If you're building an AI interpretation layer: key is constraining the model to use proper BaZi terminology and framing everything as "tendencies"

Fortune telling is a 3,000-year-old language. AI is the first truly fluent translator.

I Built an AI Fortune-Telling App with Chinese Astrology — Here's What I Learned About DeepSeek

kk mors — Thu, 07 May 2026 17:35:58 +0000

Two months ago I knew nothing about Chinese astrology. I didn't even know my own zodiac sign.

Now I've built an app that calculates BaZi (八字) charts and generates AI-powered readings. Here's what went right, what broke, and why DeepSeek is both amazing and frustrating.

What is BaZi?

BaZi — literally "Eight Characters" — is a Chinese fortune-telling system based on your birth date and time. It maps your life to five elements (Wood, Fire, Earth, Metal, Water) and their interactions.

A BaZi chart looks at four pillars: year, month, day, and hour of birth. Each pillar has a Heavenly Stem and an Earthly Branch, giving you eight characters total. From these, you derive the Day Master (your core self), identify element balances, and interpret life patterns.

Westerners might call it "Chinese astrology on steroids." There's no hand-waving about "Mercury in retrograde" — BaZi is algorithmic. Given the same inputs, you get the same chart every time. That predictability is why I thought: I can code this.

The Tech Stack

Backend: FastAPI (Python), single file, no ORM
Astrology engine: lunar-python — a Chinese library that handles the lunar calendar and sexagenary cycle calculations
AI: DeepSeek Chat API (deepseek-chat, not deepseek-reasoner)
Frontend: Next.js 16 with Tailwind CSS
Payments: Gumroad (digital product) + NowPayments (crypto)
Hosting: Single VPS, Nginx reverse proxy, HTTPS via Let's Encrypt

Total cost to build: ~$5/month VPS + API calls (~$0.01 per reading).

The Hard Part: DeepSeek Prompt Engineering

I tried DeepSeek's reasoning model first (deepseek-reasoner). Big mistake. The reasoning tokens consumed 16K tokens of context, then the final content field came back empty. Not an error — just empty. No explanation. The reasoning was "complete" in the model's mind, but the actual response never materialized.

Switching to deepseek-chat fixed the empty response problem immediately. But it introduced a new one: the model kept confusing the user's gender.

In BaZi, the Day Master's gender determines which elements are favorable. If you get the gender wrong, the entire reading is wrong. DeepSeek kept defaulting to male or ignoring the gender field entirely.

The fix that worked: I moved the gender instruction to the very top of the system prompt, before everything else. Not buried in the middle. First sentence: The person is [male/female]. And I reinforced it in every user message: Gender: [male/female], Birth: [date], Time: [time].

Only then did it stop hallucinating the gender.

# The working system prompt structure
system_prompt = f"""You are a professional BaZi fortune teller.
The person is {gender}. Use 乾造 for male, 坤造 for female.

BaZi Chart:
{chart_data}

Interpret this chart according to classical BaZi principles...
"""

What lunar-python Actually Does

lunar-python is the unsung hero here. It handles:

Converting Gregorian dates to lunar calendar dates
Calculating the sexagenary cycle (干支) for any timestamp
Determining the exact hour pillar (時柱) based on birth time
Identifying the Day Master (日主) element and strength
Mapping all ten gods (十神) relationships between stems

Without this library, I'd be reimplementing a thousand years of Chinese calendar math. The author (6tail) has been maintaining it since 2015 and it's rock solid.

from lunar_python import Lunar, Solar

solar = Solar.fromYmdHms(1988, 12, 30, 14, 0, 0)
lunar = solar.getLunar()

# Get the eight characters
bazi = lunar.getEightChar()
print(bazi.getYear())   # 戊辰
print(bazi.getMonth())  # 甲子
print(bazi.getDay())    # 己未
print(bazi.getTime())   # 辛未

The Architecture Decisions I Don't Regret

No database for readings. Each reading is a stateless API call. The BaZi chart is calculated server-side, sent to DeepSeek, and returned. Nothing is stored. This simplified deployment dramatically — no migrations, no backups, no GDPR headaches.

Single VPS, no microservices. FastAPI on port 8000, Next.js on port 3001, Nginx in front. It's not trendy, but it works and the latency is under 2 seconds end-to-end.

Gumroad for payments. I thought about Stripe. Gumroad took 10 minutes to set up. They handle VAT, refunds, and file delivery. For a solo dev shipping a side project, the 10% fee is worth not building billing infrastructure.

What I'd Do Differently

Test with real users sooner. The first version had Chinese-only output because my test data was all Chinese prompts. Took a real user to point out that English-speaking visitors got Chinese responses.
Add analytics from day one. I shipped without any tracking and had no idea if anyone was visiting. Turned out my first real user found the site through Instagram, not any of my planned channels.
DeepSeek rate limits are brutal. At peak times, API latency jumps from 2s to 15s. Adding a queue or fallback model is on the roadmap.

The Product

If you're curious, the app is at soulchart.cc. There's a free preview that shows your BaZi chart with the Day Master and element distribution. Full readings with AI interpretation are paid — keeps the API costs sustainable.

I built this because I was fascinated by the intersection of ancient divination and modern AI. The math is deterministic, but the interpretation is where it gets interesting. DeepSeek doesn't "believe" in BaZi — it just understands the symbolic system surprisingly well.

That's either profound or mildly unsettling. I haven't decided which.

Built with FastAPI, DeepSeek, lunar-python, and Next.js. Open to questions about the BaZi calculation pipeline or prompt engineering approach.

I Built an AI-Powered Chinese BaZi (八字) Fortune Teller — Here's What DeepSeek Revealed About Destiny

kk mors — Wed, 06 May 2026 02:49:09 +0000

The Algorithm That's Been Running for 3,000 Years

Most people think "Chinese fortune telling" is either superstitious nonsense or a mysterious old man with a beard.

The reality? BaZi (八字, literally "Eight Characters") is a deterministic algorithm. Your birth year, month, day, and hour map to specific Heavenly Stems (天干) and Earthly Branches (地支). These aren't random — they follow a 60-year cycle that's been documented since the Han Dynasty.

When I first learned this, I thought: This is literally a function. Input = birth datetime. Output = personality/life chart. Why can't I automate this?

Turns out, you can.

The Tech Stack

I built SoulChart over a weekend:

Python (lunar_python) → BaZi calculation engine
FastAPI → backend API
DeepSeek Chat → AI interpretation
Next.js 16 → frontend
PIL → share card generation

The hard part wasn't the astrology math (lunar_python handles the lunar/solar calendar conversion). The hard part was making the AI interpretation actually meaningful instead of generic horoscope fluff.

How BaZi Actually Works (Simplified)

Here's the core algorithm:

from lunar_python import Solar8Char, Solar

def calculate_bazi(year, month, day, hour):
    solar = Solar.fromYmdHms(year, month, day, hour)
    eight_char = Solar8Char(solar)

    return {
        "four_pillars": eight_char.getBaZi(),      # 年柱, 月柱, 日柱, 时柱
        "day_master": eight_char.getDayGan(),       # 日主 (your core element)
        "zodiac": eight_char.getShengXiao(),        # 生肖
        "five_elements": eight_char.getWuXing(),    # 五行统计
    }

Your Day Master (日主, the heavenly stem of your day pillar) is your core essence. For example:

甲/乙 (Wood) — Growth-oriented, flexible, creative
丙/丁 (Fire) — Passionate, expressive, sharp
戊/己 (Earth) — Stable, reliable, nurturing
庚/辛 (Metal) — Determined, structured, precise
壬/癸 (Water) — Adaptive, deep, intuitive

The interaction between your Day Master, the four pillars, and the Five Elements creates a uniquely detailed personality profile — much more granular than Western zodiac sun signs.

Where AI Comes In

The lunar_python library gives you the raw data. But raw data doesn't help anyone.

That's where DeepSeek shines. Instead of generic "you'll meet someone special" readings, I prompt it with the actual BaZi data:

"Day Master is 己 (Earth). Born in Dragon year. Four Pillars: [data]. Five Elements: 2 Wood, 1 Fire, 3 Earth, 1 Metal, 1 Water."

The AI reads this like a trained BaZi master and produces:

Personality analysis (accurate enough that my friends said "that's scary")
Relationship dynamics (which elements complement yours)
Career direction (which industries suit your element)
Yearly forecast (how the current year's element interacts with yours)

The Invite Mechanic — Why It's Not Just a Paywall

I hate paywalls. So instead of "pay or leave", SoulChart uses a share-to-unlock model:

Enter your birth info → Get free four pillars + short AI preview
Share with 3 friends → Unlock the full Love Report for free
Or buy instantly for $3.99-$7.99

The idea is: BaZi readings are best when discussed with friends. Your Wood element interacts with someone's Fire differently. It becomes a social experience.

What I Learned Building This

Ancient systems are underrated. BaZi has been refined for millennia. The fact that it maps to a deterministic algorithm makes it perfect for AI augmentation.
DeepSeek handles Chinese cultural context better than GPT. For non-Western subjects like BaZi, specialized models make a real difference.
Gen Z loves this stuff. The astrology + tech crossover resonates with younger audiences who want personalized digital experiences.
Free preview + social unlock converts better than free trial. People are more willing to share than to pay upfront — and sharing brings more users.

Try It Yourself (Free, No Signup)

The free preview gives you your Four Pillars chart, Day Master analysis, and Zodiac sign immediately. No email required.

👉 Get Your Free BaZi Reading

If you invite 3 friends, the full Love Report unlocks automatically. Or grab the complete reading for $3.99.

I'd love to hear: What's your Day Master? Drop your birth year + animal in the comments, and I'll tell you what your element says about your personality. 🔮

I Built an AI Reddit Lead Monitor That Finds Customers Automatically

kk mors — Tue, 28 Apr 2026 12:30:08 +0000

Manual Reddit marketing is a waste of time. You scroll for hours, find 3 relevant posts, write replies, and get banned for self-promotion. I built a system that does the finding and filtering automatically.

The Problem with Reddit Marketing

Too many subreddits to monitor manually
Most posts are not relevant to your product
Self-promotion rules are confusing and vary by subreddit
Writing natural replies is time-consuming
Easy to get banned if you do it wrong

My Solution: Reddit Lead Monitor

The system has 3 layers:

Layer 1: Scanning

Uses Reddit's public JSON API (no auth needed — just append .json to any Reddit URL) to scan target subreddits every hour.

# Fetching posts is this simple
url = "https://www.reddit.com/r/SideProject/new.json?limit=25"
# No API key needed for reading

Layer 2: Filtering

Each post is scored 0-100 across 5 dimensions:

Dimension	Weight	What It Measures
Problem Match	30%	Does the post describe a problem you solve?
Intent Signal	25%	Is the author looking for a solution?
Product Fit	20%	How directly does your product help?
Engagement Potential	15%	Will your reply get visibility?
Subreddit Rules	10%	Can you self-promote here?

70+ = Reply immediately. 50-69 = Reply later. Below 50 = Skip.

Layer 3: Reply Generation

The Milestone Approach (anti-ban):

Help first — Genuinely answer their question
Then mention your product as a relevant resource
Never lead with your product link

Bad: "Check out my product! It solves your problem! [link]"
Good: "I had the same issue. What worked for me was [approach]. 
      I actually built [product] for this exact use case. [link]"

The Anti-Ban Safety System

Max 5 replies per hour across all subreddits
Always customize at least 30% of each reply
Never reply to the same user twice in 24h
Match the subreddit's tone (casual vs technical)
Track which subreddits allow self-promotion
Never use marketing language ("game-changing", "revolutionary")

Results After 2 Weeks

Scanned 12 subreddits daily
Found 15-25 high-relevance leads per day
Posted 8-12 natural replies per day
Generated 340 clicks to product pages
Converted 12 paying customers ($480 revenue)
Zero bans or warnings

Subreddit Targeting Strategy

Tier 1 (Direct fit): r/SideProject, r/imadethis, r/AlphaandBetaUsers
Tier 2 (Problem-aware): r/webdev, r/Entrepreneur, r/SaaS, r/ChatGPT
Tier 3 (Volume): r/technology, r/startups

The key insight: Tier 2 subreddits have the best ROI. People there have the problem but haven't found a solution yet.

What You Get

The Reddit Lead Monitor Pack includes:

5 AI agent skill files (works with any AI agent)
Production Python script (scan, filter, score, generate replies)
Reply templates for 4 scenarios
Subreddit targeting worksheet
No Reddit API keys needed

If you're spending more than 30 minutes a day on Reddit marketing, you need this.

What's your Reddit marketing strategy? Would love to compare approaches.

I Built an AI Product Trend Radar That Spots Winning Products Before Competitors

kk mors — Tue, 28 Apr 2026 12:01:44 +0000

Every day, thousands of products trend on Amazon and TikTok Shop. By the time most sellers notice, the early-mover advantage is gone.

I built a Product Trend Radar — an AI-powered commerce intelligence system that scans Amazon and TikTok Shop daily to find trending products, analyze competition, mine review insights, and score opportunities before they saturate.

How It Works

The radar runs on 6 AI agent skills working together:

1. Amazon Product Scout

Scans bestsellers, new releases, and movers and shakers across your target categories. Extracts ASIN, price, rating, review count, BSR, and seller information.

2. TikTok Shop Scout

Monitors trending products, viral content, and creator partnerships. Measures content velocity — the number of videos, views, and engagement a product generates in 24h/7d windows.

3. Review Miner

Deep-mines product reviews to find:

What customers love (copy these features)
What they hate (fix these pain points)
What they wish existed (build these features)
Which competitors they mention

4. Competitor Tracker

Monitors competitor pricing, listing changes, inventory signals, and ranking movements. Alerts you when a competitor drops price, adds new variations, or runs out of stock.

5. Opportunity Scorer

Multi-factor scoring engine that rates each product 0-100 across 5 dimensions:

Dimension	Weight	What It Measures
Demand Signal	25%	BSR trend, search volume, TikTok views
Competition Level	20%	Seller count, brand concentration
Review Sentiment	20%	Pain points, feature gaps
Content Velocity	15%	Social momentum, creator activity
Profit Potential	20%	Margins, shipping, seasonality

80+ = Green light. 60-79 = Investigate. Below 60 = Skip.

6. Daily Briefing Generator

Combines all signals into a concise morning report with:

Market pulse (biggest movers)
Hot opportunities with scores and margins
Competitor alerts
Prioritized action items

The Scoring Framework in Practice

# Example: Scoring a stackable bento box
product = {
    "title": "Stackable Bento Box",
    "bsr": 1923,           # Improving rapidly
    "reviews": 156,         # Low competition (few reviews)
    "rating": 3.8,          # Room for improvement
    "tiktok_views": 500000, # Viral content
    "seller_count": 5,      # Fragmented market
    "estimated_margin": 68, # Great margins
}

# Result: 84/100 — High Opportunity
# Action: Source immediately from 1688 at $2.10, sell at $19.99

What You Get

The Product Trend Radar Pack includes:

6 AI agent skill files — Ready-to-use prompts for any AI agent (Hermes, OpenClaw, Manus, ChatGPT)
3 Python scripts — Amazon stealth scraper, opportunity scoring engine, configurable settings
Templates — Daily briefing, product scorecard, competitor profile
Examples — Sample outputs for every component

Works with or without coding. The AI agent skills need zero code — just copy the prompt and run.

Target Markets

Amazon US, EU (DE/UK/FR/IT/ES), Japan
TikTok Shop (Global)
Wildberries / Ozon (Russia)
Mercado Libre (LatAm)
1688 (sourcing)

My Results

After running this radar for 3 months:

Found 12 products scoring 80+ before they peaked
Average time from detection to listing: 5 days
3 products became top-10 BSR in their categories
One product generated $8K in its first month

The key insight: speed beats scale. Finding a trending product 2 weeks early is worth more than having 100 mediocre listings.

If you sell on Amazon, TikTok Shop, or any e-commerce platform, the Product Trend Radar Pack will help you spot winners before the crowd.

What tools do you use for product research? Would love to compare notes.

Agent Command Center — Manage Multiple AI Agents from One Dashboard

kk mors — Tue, 28 Apr 2026 10:33:38 +0000

Running multiple AI agents (trading bots, content generators, monitors) quickly becomes chaos. I built a command center to manage them all from one place.

The Problem

If you're running AI agents like me:

Trading monitor that runs 24/7
Content bots that post on schedule
Scraping agents that collect data
Customer service bots

You end up with:

Processes scattered across terminals
No visibility into what's running
Hard to restart/stop individual agents
No centralized logging
Memory/CPU usage unclear

The Solution

Agent Command Center provides:

1. Dashboard

Real-time view of all running agents:

Status (running/stopped/error)
CPU and memory usage
Last action taken
Uptime tracking

2. Process Management

# Start an agent
acc start crypto-monitor

# Stop gracefully
acc stop content-bot

# Restart with new config
acc restart scraper --config new_targets.yaml

# View logs
acc logs trading-agent --tail 50

3. Alerting

Get notified when:

An agent crashes or hangs
Memory usage exceeds threshold
An agent hasn't produced output in X minutes
Error rate spikes

4. Scheduling

Built-in cron-like scheduling:

Run agents at specific times
Set up recurring tasks
Chain agents together (output of A feeds into B)

5. Logging & Analytics

Centralized log aggregation
Performance metrics per agent
Cost tracking (API calls, compute time)
Historical run data

Get the Agent Command Center and take control of your AI agent fleet.

How do you manage your AI agents? Would love to hear your setup.

Python Crypto Indicators — Production-Ready Technical Analysis Library

kk mors — Tue, 28 Apr 2026 10:28:27 +0000

I got tired of crypto trading libraries that are either too bloated or too basic. So I built a focused set of Python indicators that I actually use in production.

What's Included

Trend Indicators

EMA/SMA crossovers — With signal generation
Ichimoku Cloud — Full implementation with all 5 lines
ADX — Trend strength measurement

Momentum Indicators

RSI — With divergence detection
MACD — With histogram and signal crossovers
Stochastic RSI — Combining both for better signals

Volatility Indicators

Bollinger Bands — With squeeze detection
ATR — For dynamic stop-loss placement
Keltner Channels — Combined with BB for Squeeze play

Volume Indicators

OBV — On-balance volume
VWAP — Volume-weighted average price
Volume Profile — Identify high-volume zones

from crypto_indicators import RSI, MACD, BollingerBands

# Quick analysis
df = load_candle_data("ETH/USDT", timeframe="4h")

df["rsi"] = RSI(df["close"], period=14)
df["macd"], df["signal"], df["hist"] = MACD(df["close"])
df["bb_upper"], df["bb_mid"], df["bb_lower"] = BollingerBands(df["close"])

# Find RSI divergence
divergences = RSI.detect_divergence(df["close"], df["rsi"])
print(f"Found {len(divergences)} divergences")

Why This One?

Zero dependencies beyond numpy/pandas — No heavy frameworks
Vectorized calculations — Fast on large datasets
Signal generation built-in — Not just values, but actionable signals
Backtested — Every indicator tested against historical data
Type hints — Full type annotations for IDE support

Get the Python Crypto Indicators library.

What indicators do you rely on for crypto trading?

AI Crypto Monitor — Automated Trading Signals with Multiple AI Models

kk mors — Tue, 28 Apr 2026 10:23:16 +0000

Crypto markets never sleep, but you do. I built an AI-powered monitor that watches the markets 24/7 and sends trading signals when conditions are right.

How It Works

The monitor uses multiple AI models to analyze market conditions:

Technical Analysis Agent — Reads charts, identifies patterns (RSI, MACD, support/resistance)
Sentiment Agent — Monitors social media and news for market sentiment shifts
On-Chain Agent — Tracks whale movements, exchange flows, and DeFi metrics
Decision Engine — Combines all signals and generates a confidence score

# Signal example
{
    "token": "ETH",
    "action": "LONG",
    "confidence": 0.87,
    "entry": 3420,
    "stop_loss": 3350,
    "take_profit": 3580,
    "reasoning": [
        "RSI oversold on 4H timeframe",
        "Whale accumulation detected (3 large wallets)",
        "Sentiment turning positive on X/Twitter"
    ],
    "risk_level": "MEDIUM"
}

Features

Multi-model consensus — Not relying on a single AI's judgment
Conservative strategy — All 4 conditions must be met before signaling
Telegram alerts — Get signals instantly on your phone
Backtesting — Test strategies against historical data
Customizable parameters — Adjust risk tolerance and trading pairs

My Strategy (V2.4)

Very conservative — 4 conditions must ALL be met:

Technical indicators aligned
Sentiment confirms direction
On-chain data supports
No major risk events upcoming

This means fewer signals but higher win rate.

Get the AI Crypto Monitor and start getting smarter trading signals.

What's your approach to crypto trading? Do you use AI for analysis?

Jimeng AI Free API — Access ByteDance's Image Generation for Free

kk mors — Tue, 28 Apr 2026 10:18:06 +0000

ByteDance's Jimeng (即梦) AI generates stunning images, but there's no official free API. I reverse-engineered the web interface to create a free API wrapper.

What is Jimeng AI?

Jimeng is ByteDance's (TikTok's parent company) AI image generation model. It produces high-quality images with:

Excellent Chinese text rendering in images
Strong artistic style control
Fast generation times
Multiple model options

The Free API

I built a wrapper that lets you call Jimeng through a simple REST API:

import requests

# Generate an image
response = requests.post("http://localhost:8080/generate", json={
    "prompt": "A cyberpunk city at sunset, neon lights reflecting on wet streets",
    "width": 1024,
    "height": 1024,
    "style": "vivid"
})

image_url = response.json()["url"]

Features

REST API interface — Simple HTTP calls
Multiple models — Access different Jimeng model variants
Batch generation — Generate multiple images at once
Style presets — Photorealistic, anime, oil painting, etc.
No API key needed — Uses free web access

Limitations

Rate limited to ~20 images per hour
Requires a valid Jimeng web session (cookie)
Not for commercial use (check ByteDance's terms)

Get the Jimeng AI Free API setup guide and code.

Has anyone else worked with Jimeng or other Chinese AI image generators?

X/Twitter Automation Toolkit — Schedule Threads, Auto-Reply, and Grow Your Audience

kk mors — Tue, 28 Apr 2026 10:12:55 +0000

Growing on X/Twitter requires consistent posting and engagement. I built a toolkit that automates the repetitive parts while keeping your voice authentic.

What's in the Toolkit

1. Thread Scheduler

Write threads in advance, schedule them for optimal posting times.

Supports up to 25-tweet threads
Image attachment support
Optimal timing based on your audience's timezone

2. Smart Auto-Reply

Monitor keywords and auto-reply to relevant tweets:

// Example: Auto-reply to tweets about "AI API pricing"
const keywords = ["AI API", "API pricing", "cheap API"];
const replyTemplate = "Great point! Have you tried Chinese AI APIs? They're 80% cheaper...";

// The bot monitors your timeline and replies to matching tweets
// with natural-sounding responses (not spam!)

3. Engagement Tracker

Track who engages with your content:

Top engagers list
Reply-to-engagement ratio
Best performing tweets
Follower growth analytics

4. Content Calendar

Plan your content week by week:

Mix of original content, threads, and engagement
Template prompts for different content types
Performance tracking per content category

Important Notes

Always follow X/Twitter's terms of service
Don't spam — quality over quantity
Use auto-reply sparingly and make responses natural
The toolkit helps you be more efficient, not replace your voice

Get the X Automation Toolkit and start growing your X presence.

What tools do you use for social media automation?

I Built a Telegram Customer Service Bot with AI — Here's How It Works

kk mors — Tue, 28 Apr 2026 10:07:43 +0000

Customer service is one of the most time-consuming parts of running a business. I built a Telegram bot that handles 80% of customer inquiries automatically using AI.

Why Telegram?

Huge user base in Asia and Eastern Europe
Bot API is well-documented and free
Supports rich messages, inline keyboards, and payments
Customers are already on Telegram

How It Works

The bot architecture:

Message intake — Customer sends a message to your Telegram bot
Intent classification — AI determines what the customer wants (pricing, support, feature request, etc.)
Knowledge base lookup — Bot searches your product documentation
Response generation — AI crafts a natural response
Escalation — Complex queries get forwarded to a human

# Core bot logic
from telegram import Update
from telegram.ext import Application, MessageHandler

async def handle_message(update: Update, context):
    user_msg = update.message.text
    intent = classify_intent(user_msg)

    if intent.confidence > 0.85:
        answer = search_knowledge_base(intent)
        response = generate_response(answer, user_msg)
        await update.message.reply_text(response)
    else:
        await escalate_to_human(update, user_msg)

Features

Multi-language support — Responds in the customer's language
Knowledge base integration — Connects to your docs, FAQ, and product info
Conversation history — Remembers context across messages
Analytics dashboard — Track common questions, response times, satisfaction
Human handoff — Seamless escalation when AI can't help

If you want to set up your own AI-powered Telegram CS bot, check out the Telegram CS Bot.

Has anyone else built customer service bots? What's your stack?