Büyük Samsung grevi son dakikada askıya alındı

yazar
Samsung

SamsungDün, şirket yönetimi ile işçi sendikası arasında yürütülen prim ödemesi müzakerelerinin sonuçsuz kalmasının ardından, Samsung’un Güney Kore merkezli yaklaşık 47 bin çalışanının 18 gün sürecek büyük bir greve hazırlandığı haberi gündeme gelmişti. Sendika, Samsung’dan işçi ikramiyelerine uygulanan ve yıllık maaşın yüzde 50’sine denk gelen tavan sınırın kaldırılmasını istiyor ve ayrıca yıllık faaliyet karının yüzde 15’inin işçi ikramiyelerine ayrılmasını talep ediyordu. Bunun üstüne başlatılan ve Güney Kore Çalışma ve İstihdam Bakanı Kim Young-hoon liderliğinde yürütülen yeni müzakereler, tarafların geçici bir anlaşmaya varmasıyla sonuçlandı. Buna bağlı olarak 18 günlük grev son dakikada askıya alındı. Bu grevin hem Samsung’a hem de tüm bellek/çip tedarik sektörüne çok büyük olumsuz etkileri olacaktı.

Büyük Samsung grevi son dakikada askıya alındı yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.

I am trying to make my first online sale in 10 days as a developer. Here is what happened on Day 2.

yazar

I set a challenge for myself: generate my first online revenue from developer tools in 10 days. No ads budget. No existing audience. Just build, publish, distribute.

It’s Day 2. Here’s what’s happened.

What I’m selling

I built 7 digital products aimed at WordPress freelancers and IT professionals:

  • Bash/PowerShell maintenance automation scripts (19 PLN / ~$5 USD)
  • Service agreement templates, proposal templates, onboarding checklists (49 PLN / ~$13 USD)
  • Client acquisition cold email sequences (29 PLN / ~$8 USD)
  • Performance audit kit (19 PLN / ~$5 USD)
  • Two free WordPress checklists (lead magnets)
  • AI prompt pack for tech freelancers (120 prompts, $12 USD)

All on Gumroad.

Day 1: Build and publish

Built the products. Listed them on Gumroad. Published the first 7 articles on dev.to linking to them.

Sales: 0.

Day 2: The strategy problem

Published 8 more articles (15 total). Wrote detailed, technical content: WP-CLI automation, staging environments, backup strategies, plugin conflict diagnosis.

Tried to distribute:

  • Reddit — new account, can’t create API apps, can’t post in r/WordPress (karma requirement). Blocked.
  • LinkedIn — browser extension restrictions. Blocked.
  • Facebook — same. Blocked.
  • Hacker News — no write API. Blocked.

Dev.to organic views after 15 articles: 52. Sales: 0.

That’s when I had to stop and think.

The strategy failure

The content was fine. The problem was math.

15 articles × 3.5 average views = 52 total views. At 1% conversion, that’s 0.52 expected sales. I was building SEO content — a strategy that takes 3-6 months to work — and expecting sprint results.

What drives immediate traffic?

  • Social media (blocked)
  • Email list (zero subscribers)
  • Paid ads (no budget)
  • Going viral (not predictable)
  • Community engagement (limited by new accounts)

I had none of these. The distribution channels I needed required either an existing audience or a platform relationship I didn’t have.

The pivot

Instead of more WordPress content targeting a small niche, I shifted to AI — larger audience on dev.to, different readers.

published: 15 AI prompts for tech freelancers (the uncomfortable ones included)

The logic: AI Prompt Pack ($12 USD) is the only product priced in USD (accessible internationally). It’s also the only one I hadn’t written any content around. 15 articles promoting 6 products, zero articles promoting the AI pack.

Also published: How I use AI in my WordPress maintenance business — bridges both audiences.

What I’ve learned so far

1. Distribution is the product. The tools are built. The articles are written. The bottleneck is getting them in front of people who would pay for them. Content without distribution is a tree falling in an empty forest.

2. Platform restrictions are real. New accounts can’t do much. Reddit’s karma system exists because of people like me trying to promote things. LinkedIn blocks API access for competitive reasons. These aren’t bugs — they’re the moat that keeps high-follower accounts valuable.

3. Organic SEO is a 3-month play. You don’t write 15 articles and see results in 48 hours. Google indexes slowly. Search traffic compounds. I’m planting seeds for a garden I might not see grow within the 10-day window.

4. The free products are the funnel entry. The two free WordPress checklists are the right strategy — they generate email captures that could become sales. But with 0 downloads of the free products so far, even the funnel isn’t working yet.

5. The gap between “built” and “sold” is enormous. I knew this intellectually. Now I feel it.

Day 3 plan

Current position: 17 articles, 92 total views, 0 sales, 8 days left.

What I’m working on:

  • Finding newsletter submission opportunities (WP Tavern, Smashing, dev-focused newsletters)
  • Improving Gumroad product pages for better conversion when people do land
  • Writing content that might actually generate engagement/reactions rather than just views

The honest target: 1 sale before Day 10. That’s $5-13 USD. The challenge was “generate revenue” not “generate significant revenue.”

What would you do differently at Day 2 of a zero-audience product launch? Curious what I’m missing.

Products if you want to check them: devautomation.gumroad.com

I Built The UnoQ’s Claw: A Tiny Agentic AI Assistant That Lives Inside an Arduino Uno Q

yazar

Every “AI on hardware” demo you have ever seen has a LLM behind it. The user talks to a board via a terminal or Telegram, and the board calls an API to have a cloud model do the work. QClaw flips that arrangement. The Arduino Uno Q hosts the language model, runs the agent loop, drives the compile toolchain, and flashes its own microcontroller.

Ask QClaw to scroll “QClaw” across the LED matrix and it does. End to end. On the board. Offline.

QClaw has an eight-tool agentic surface, a fifteen-skill pre-router, and a direct OpenOCD flash route that makes autonomous uploads actually execute. A dual-path runtime lets you pick speed or full hardware control on the same model.

Why the Uno Q Is the Right Board for This

The Arduino Uno Q is a split-silicon device. It looks like a classic Arduino on the outside, but it is two boards in a trench-coat:

The MPU and MCU share the same PCB. The MPU can hold the MCU in reset and reprogram its flash directly through GPIO pins wired to SWD via the linuxgpiod driver. No USB cable between them. No probe. No second machine. That is the genius of QClaw.

The agentic loop orchestrates the full sketch lifecycle across the Arduino Uno Q’s dual-silicon topology, with the MPU driving the loop and the MCU executing the resulting firmware. This is how QClaw generates, compiles, flashes, and observes.

The QClaw arduino tool invokes OpenOCD directly at the correct address. The tool compiles with arduino-cli compile --fqbn arduino:zephyr:unoq --export-binaries, picks up the resulting .elf-zsk.bin, and pipes it through OpenOCD over the GPIO SWD bridge. No SSH, no network credentials, no remote OCD tunnel. Just MPU to MCU, on the same board. Sub-second flash once the binary is on disk.

Four gigs of RAM is also more than enough to host a Qwen3.5 0.8B Q4_0 model with an 8K context window, mlocked, with q8_0 KV cache. QClaw lives on the Uno Q at around 1.3 GB. Decode runs at roughly 8 tokens per second. Slow next to a desktop GPU, fast enough that a sketch compiles and flashes before you have finished your coffee.

*How To Use QClaw *

QClaw ships two runtimes on top of the same llama-server backend, the same SOUL.md, and the same 23-rule pre-router. They differ in what wraps the LLM call.

Agentic path (make qclaw-agentic). the qclaw Go gateway sits in front of the model. It runs channel adapters (terminal, SSH, Telegram), the multi-iteration agent loop, the pre-router, and the eight-tool dispatcher. This is the production default. It is the only path that can actually compile and flash a sketch.
Direct path (make qclaw-direct). A thin Python REPL POSTs directly to llama-server after running the same pre-router rules in Python. No loop, no tools, no Telegram. About 33 percent lower latency on pure factual prompts at equivalent correctness, because there is no tool schema in the prompt and no second iteration.

Use the agentic path when you want a sketch flashed or a frame captured. Use the direct path when you just want to ask which pins on the Uno Q do PWM.

Drop in two commands and you have a session: 

git clone https://github.com/laurenvil/Uno-QClaw.git ~/ArduinoApps/QClaw     

cd ~/ArduinoApps/QClaw     

git submodule update --init --recursive     

# Download the inference engine     

cd yzma && make download-llama.cpp && cd ..     

# Download the model (~490 MB for Q4_0)     

mkdir -p ~/models     

wget -O ~/models/Qwen_Qwen3.5-0.8B-Q4_0.gguf      

     'https://huggingface.co/Qwen/Qwen3.5-0.8B-GGUF/resolve/main/Qwen3.5-0.8B-Q4_0.gguf'     

# Build, install arduino-cli, configure (one time)     

make qclaw-install     

# Start a session — pick a path     

make qclaw-agentic    # full agent loop + 8 tools (compile/upload/camera/sysfs_led/network/i2cdetect)     

make qclaw-direct     # pre-router + direct API (fast Q&A, no tools)

make qclaw-install builds the Go binary, copies the system prompt and the fifteen-skill tree into ~/.qclaw/workspace/, installs arduino-cli plus the arduino:zephyr core, and runs an interactive wizard that sets up the optional Telegram gateway.

Once it is running, the agent has eight narrowly-scoped tools available:

read_file, write_file, list_dir for workspace navigation
arduino for compile and flash via OpenOCD
camera for single-frame V4L2 capture through GStreamer
sysfs_led for the MPU-side RGB LEDs at /sys/class/leds/*
network for hostname, interfaces, and the default gateway, all read-only stdlib Go
i2cdetect for listing and scanning Linux I²C buses with -y -r only
No general exec. No general shell. Every tool validates its arguments against an allow-list. The total tool schema is around 3.4K characters, leaving plenty of room for the system prompt at an 8K context window.

The Pre-Router: Skills, Not RAG

The pre-router is the part of QClaw that does the heavy lifting on a 0.8B model. It is not RAG. It is a flat table of 23 keyword regex rules across 15 skills. When you send a message, the pre-router scans it, finds matching rules, and inlines the relevant SKILL.md plus its referenced files directly into the system prompt before the LLM call.

The model never has to call read_file for canonical skill content. The content is already there. At 0.8B scale, a read_file call costs a full LLM iteration, roughly 10 to 20 minutes of cold prefill plus decode. The pre-router amortizes that to zero.

*The skills cover: *

Sketch fundamentals: blink, breathe, button, potentiometer, servo, compile and upload, CAN bus, DAC, OPAMP
The 13×8 LED matrix with the canonical Arduino_LED_Matrix template
Uno Q hardware: pin tables, voltage rules, connectors, power
Dual-chip workflow: Bridge RPC, App Lab, Bricks
Linux-side capabilities: Wi-Fi, Bluetooth, camera, OpenCV, microphone, sysfs LEDs
Plug-and-play Modulino sensors
Each skill is just a directory under workspace/skills/<name>/ with a SKILL.md and optional reference files. Adding a new one is a matter of writing the markdown and adding a regex rule.

*Try It *

Repo:https://github.com/laurenvil/Uno-QClaw

Issues, forks, and pull requests are welcome at https://github.com/laurenvil/Uno-QClaw. If you have an Arduino Uno Q on your desk, you can have a self-flashing AI assistant sitting on it tonight, with the Ethernet cable unplugged.

How I use AI to run a WordPress maintenance business (6 concrete examples)

yazar

Running a WordPress maintenance business sounds low-tech: update plugins, check backups, send reports. But I use AI every week to handle the parts that used to take the most time: client communication, documentation, and troubleshooting.

Here are the specific ways I use it, with real examples.

1. Diagnosing plugin conflicts

When a site breaks after an update, you need to move fast. Instead of starting from scratch, I paste the error into Claude or ChatGPT with context: 

Context: WordPress site broke after updating WooCommerce from 8.6 to 8.7.
Error: "Fatal error: Call to undefined function wc_get_order() in /wp-content/plugins/custom-checkout/checkout.php on line 47"
Question: What's causing this and what's the fastest fix?

The response usually identifies the root cause (a deprecated function, a compatibility break) and suggests the fix. What used to take 20-30 minutes of digging through changelogs now takes 5.

2. Writing client maintenance reports

Every client gets a monthly report. Writing 8 reports from scratch every month used to take 3+ hours.

Now I log the key data (what was updated, any issues found, backup status, performance baseline) and paste it into this prompt: 

Write a professional maintenance report for a WordPress site. This month:
- Plugins updated: [list]
- Core updated: yes/no, from X to Y
- Issues found: [describe or "none"]
- Backup location: [where]
- Performance score: [before] -> [after]
- Recommendations: [list or "none"]
Tone: professional, non-technical. Client is a [type of business]. Keep under 250 words.

The AI writes a clean, professional report. I review it, adjust anything client-specific, send. 8 reports in 45 minutes instead of 3 hours.

3. Responding to client emergencies

“My site is down” emails arrive at the worst times. The client is panicking. You need to respond fast, sound calm, and set expectations — before you’ve even diagnosed the problem.

Send that in under 2 minutes. Then diagnose. The client feels handled while you work.

4. Writing service agreements and scope clarifications

When a client asks for something outside the original scope (“can you just add a contact form?”), I need to respond in a way that’s firm without being rude.

This used to take me 10-15 minutes of careful writing. Now it’s 2 minutes.

5. Researching hosting issues

When something is wrong at the hosting level (slow server response, caching issues, PHP version incompatibilities), I describe the situation: 

My client's WordPress site on SiteGround shared hosting started returning 504 Gateway Timeout errors at random intervals. PHP version is 8.1. Site uses WooCommerce, LiteSpeed Cache, and Elementor. No recent changes. What are the most likely causes and how do I diagnose each one?

The response gives me a structured diagnostic path. Instead of starting with the most complicated possibility, I work through the most common causes first. Saves time, looks professional to the client.

6. Generating WP-CLI commands I can’t remember

I use WP-CLI constantly, but I can’t memorize every flag. Instead of reading documentation: 

Give me the WP-CLI command to: export the database from /var/www/client, name the file with today's date, and verify the export file exists and isn't empty.

Three seconds. Done.

The honest assessment

AI doesn’t maintain WordPress sites. I still need to:

  • Actually run the updates
  • Verify the site still works
  • Make judgment calls about risky changes
  • Manage the client relationship

But it handles the writing, the communication, and the research that surrounded maintenance work. That’s about 30-40% of the total time.

What I use

For the AI prompts I use weekly (not just for WordPress — full freelance toolkit): AI Prompt Pack for IT Freelancers — 120 prompts, $12 USD, tested on Claude/ChatGPT/Gemini.

For the WordPress automation scripts that run the actual maintenance: WordPress Agency Automation Bundle — Bash + PowerShell scripts, monthly report generator.

Related articles

All tools: devautomation.gumroad.com

Which part of client work do you use AI for? Drop it in the comments.

Avoiding the Ecommerce Trap In Data-Driven Apps

yazar

The Problem We Were Actually Solving

My goal was to build a seamless ebook purchase experience for users in various regions, where PayPal, Stripe, Gumroad, and Payhip were either blocked or highly restricted. I knew that our app’s unique value proposition – providing data-driven insights to its users – could be compromised if I had to resort to traditional (and inflexible) payment gateways. The problem, however, was that our existing infrastructure was tied to these platforms, making it a high-risk, high-reward move to explore alternatives.

What We Tried First (And Why It Failed)

Initially, I attempted to use a third-party ebook sales platform like E-junkie, which promised to integrate seamlessly with popular ecommerce solutions. Unfortunately, their API offered limited control over the checkout process, and I couldn’t quite get the customizations we needed without extensive custom development. We also experimented with a headless ecommerce solution like Shopify Plus, but their APIs and payment gateways still required us to expose sensitive financial data to the web, which went against our security best practices.

The Architecture Decision

After reviewing our options and weighing the pros and cons, we decided to go with an in-house solution using an embedded payment processor called Mollie. This allowed us to handle ebook purchases directly within our app, without exposing our users to 3rd-party payment gateways. The architecture decision came with its own set of trade-offs, such as increased complexity and responsibility for managing payment processing ourselves, but it ultimately gave us the flexibility to design the checkout experience that best suited our app’s unique requirements.

What The Numbers Said After

After implementing the new payment processing system, we saw a significant drop in abandoned cart rates (from 35% to 12%) and an increase in average order value by 20%. This was a testament to the tailored checkout experience we had designed for our users. Plus, the integration was smooth enough to meet our stringent data freshness SLAs (ensuring that the ebook inventory levels and purchase history were up-to-date within 5 minutes of the transaction).

What I Would Do Differently

Looking back, I would have done even more due diligence on the specific regulations and restrictions imposed by traditional payment gateways. It’s crucial to understand the nuances of payment processing in different regions to avoid the ecommerce trap altogether. I would also invest more in ensuring the in-house payment processing system is highly available, scalable, and maintainable, perhaps using distributed transactional frameworks like Apache Kafka or Rediscala.

In conclusion, navigating platform restrictions for data-driven apps can be a daunting task. However, by taking a closer look at the problem we’re trying to solve and exploring unconventional architectures, we can unlock new opportunities for growth and innovation while avoiding the limitations imposed by traditional platforms.

ICECODE — Self-hosted AI Agent Platform: Multi-Agent Swarm, Local RAG, 26-Page Web UI, 34 Platform Gateways

yazar

ICECODE is a self-hosted AI agent platform I built by unifying three open-source projects (Hermes, OpenCode, ClawX) into one cohesive system. It runs entirely on your machine — no data leaves your network.

What it does

  • Multi-Agent Swarm — pipeline and parallel orchestration: agents collaborate, pass context, and vote on answers
  • Local RAG — FAISS + sentence-transformers, 100% offline — index any file, search semantically
  • 26-Page Web UI — dashboard, chat, kanban, goals, swarm, knowledge, MCP, benchmark, and more
  • Cost Optimizer — semantic cache (skip duplicate API calls), context compressor, smart model router
  • 174 REST API routes with auto-docs (FastAPI)
  • 34 platform gateways — WhatsApp, Telegram, Discord, Slack, Email, WeChat, Feishu, and 27 more
  • 14 LLM providers — Anthropic, OpenAI, Ollama, Gemini, Mistral, Bedrock, Azure, OpenRouter…
  • 90+ agent tools — file, web, browser, terminal, vision, kanban, MCP, code execution
  • Self-learning skills — agents learn new skills at runtime, stored across sessions
  • Reinforcement learning environment for agent improvement
  • WebSocket chat — bidirectional with cancel support
  • Token tracking + cost — per-session usage across all providers

Quick start

[1m
╔══════════════════════════════════════════════════════╗
║ ICECODE Super-Agent Network — Installer ║
║ v2.0.0 ║
╚══════════════════════════════════════════════════════╝
[0m
[0;33m→[0m Checking Python version…
[0;32m✓[0m Python 3.12 found
[0;32m✓[0m Virtual environment already exists
[0;33m→[0m Installing Python dependencies…
Starting ICECODE server on http://localhost:13210…
[32m23:36:33[0m | [1mINFO [0m | React UI served at /desktop/
INFO: Started server process [423207]
INFO: Waiting for application startup.
[32m23:36:33[0m | [1mINFO [0m | ============================================================
[32m23:36:33[0m | [1mINFO [0m | ICECODE Super-Agent Network v2.0.0 starting…
[32m23:36:33[0m | [1mINFO [0m | Port: 13210
[32m23:36:33[0m | [1mINFO [0m | DB: ~/.icecode/data/icecode.db
[32m23:36:33[0m | [1mINFO [0m | Home: /home/claudiu/.icecode
[32m23:36:33[0m | [1mINFO [0m | ============================================================
[32m23:36:33[0m | [1mINFO [0m | [✓] Database initialized at ~/.icecode/data/icecode.db
[32m23:36:33[0m | [1mINFO [0m | [✓] Self-learning system ready
[32m23:36:33[0m | [1mINFO [0m | [✓] Cron scheduler ready
[32m23:36:33[0m | [1mINFO [0m | [✓] Goals system (Ralph Loop) ready
[32m23:36:33[0m | [1mINFO [0m | [✓] Knowledge auto-index task started
[32m23:36:33[0m | [1mINFO [0m | All ICECODE systems online.
INFO: Application startup complete.
ERROR: [Errno 98] error while attempting to bind on address (‘0.0.0.0’, 13210): address already in use
INFO: Waiting for application shutdown.
[32m23:36:33[0m | [1mINFO [0m | ICECODE shutting down…
INFO: Application shutdown complete.

Architecture

Cost Optimizer (new in v2)

The cost optimizer has three components that work together automatically:

  1. Semantic Cache — uses sentence-transformer embeddings + cosine similarity (≥0.92 threshold). If you ask a semantically similar question to a previous one, it returns the cached answer instantly — zero API tokens consumed.

  2. Context Compressor — when conversation history exceeds 3000 tokens, older messages are summarized instead of sent verbatim. Keeps the last 6 messages intact.

  3. Smart Model Router — analyzes prompt complexity (score 1-10) and routes to the cheapest capable model. Simple questions go to cheap models, complex reasoning goes to powerful ones.

Multi-Agent Swarm

Two orchestration modes:

Pipeline: agents run sequentially, each building on the previous output.

Parallel: all agents receive the same input simultaneously, results are merged.

Built-in templates: Research & Write, Code Review, Brainstorm, Security Audit.

Local RAG

No API keys needed. No data leaves your machine.

  • Supports , , , , , , ,
  • Chunk strategy: sliding window (512 tokens, 50 overlap)
  • Embeddings: (90MB, runs locally)
  • Vector store: FAISS IndexFlatL2
  • Persistence:

Index a directory:
{“detail”:[{“type”:”json_invalid”,”loc”:[“body”,0],”msg”:”JSON decode error”,”input”:{},”ctx”:{“error”:”Expecting value”}}]}

Tech stack

Backend — Python 3.12 · FastAPI · Uvicorn · SQLite · Pydantic v2 · FAISS · sentence-transformers · Loguru

Frontend — Single HTML file, no build step · Pure JS ES2022 · CSS variables · Server-Sent Events + WebSocket

TypeScript — pnpm workspaces · turbo · CLI with Ink TUI · 14 LLM provider protocols · MCP client

Desktop — Electron 33

Infrastructure — Docker · GitHub Actions CI · pytest (108 tests) · ruff

Links

If you try it, I’d love to hear what you think. Issues and PRs welcome.

Five primitives I exercised end-to-end on world-model-mcp’s own repo

yazar

I shipped four releases of world-model-mcp in twelve days. v0.6.1 to v0.7.2. The pitch is “AI coding agents lose context across compaction, repeat the same mistakes, and hallucinate APIs that do not exist.” Before I write more about it I wanted to demonstrate the primitives on a real codebase, with real outputs, not screenshots someone has to take my word for.

The codebase is the project’s own repo. I ran python -m world_model_server.cli setup (it auto-seeded 598 entities from the source), then ran scripts/demo_seed.py which inserts the small set of constraints, facts, and a compaction audit row that real PostToolUse / record_correction hook activity would write organically over one to two weeks of development with Claude Code installed.

Every output block below is verbatim from the actual SQLite database after running the actual command. You can reproduce every output here by cloning the repo, running python -m world_model_server.cli setup, then python scripts/demo_seed.py. The script is idempotent and supports –dry-run and –reset.

Install: pip install world-model-mcp. Source: github.com/SaravananJaichandar/world-model-mcp.

1. A learned constraint denying an edit at the PreToolUse boundary

When a developer corrects the agent (rewrites console.log to logger.debug), the PostToolUse hook records the diff and infers a rule. Once that rule’s violation count crosses the hard-threshold (severity=error, count ≥ 3), the next attempt is denied at PreToolUse before the tool runs.

The constraint as the graph stores it:
{
“rule_name”: “no-console-log”,
“severity”: “error”,
“violation_count”: 5,
“description”: “Use logger.debug() not console.log() in TypeScript source. Production logs route through pino; console.log bypasses formatting and breaks downstream parsers.”,
“file_pattern”: “*.ts”,
“examples”: [
{“incorrect”: “console.log”, “correct”: “logger.debug”}
]
}
The PreToolUse hook’s actual JSON response when an edit containing console.log reaches it:
{
“hookSpecificOutput”: {
“hookEventName”: “PreToolUse”,
“permissionDecision”: “deny”,
“permissionDecisionReason”: “Hard constraint violation: no-console-log (Use logger.debug() not console.log() in TypeScript source. Production logs route through pino; console.log bypasses formatting and breaks downstream parsers.). Violated 5 times previously.”
},
“violations”: [
{
“rule”: “no-console-log”,
“severity”: “error”,
“violation_count”: 5,
“is_hard”: true,
“is_defer”: false
}
]
}
Rules in CLAUDE.md or AGENTS.md are advisory and the model treats them as suggestions. Rules with a violation count and an enforcement boundary at the edit step are binding. Both have the same source — a developer correcting the agent — but very different effect.

2. A regression warning that flags edits to a file with a recorded bug fix

get_related_bugs walks decision traces and prior bug-fix facts. When validate_change runs on a file with a recorded fix, the related-bugs query surfaces the prior fix and flags the proposed change.

The project has a bug fix on file world_model_server/knowledge_graph.py:120-135 for content-hash backfill (the migration logic must run on every initialize(), not just when the column is created). I proposed a refactor that removed the backfill loop and ran the related-bugs check:
{
“risk_score”: 0.6,
“bugs”: [
{
“bug_id”: “12457e2a-5638-46ec-a9df-02fe13b9c104”,
“description”: “Bug fix: NULL content_hash backfill must run on every initialize() to cover post-migration inserts. Earlier code only backfilled when the column was created, which left merge_from rows un-hashed and broke dedup.”,
“fixed_at”: “2026-05-10T10:17:51.737046”,
“critical_regions”: [
{“file”: “world_model_server/knowledge_graph.py”, “lines”: “120-135”}
]
}
],
“warnings”: [
“Lines 120-135 preserve fix for 12457e2a-5638-46ec-a9df-02fe13b9c104: Bug fix: NULL content_hash backfill must run on every initialize() to cover post-migration inserts. Earlier code only backfilled when the column was created, which left merge_from rows un-hashed and broke dedup.”
]
}
The risk score is 0.6 because the proposed change touched a critical region without re-implementing the fix. The warning text quotes the original bug description directly so the agent (or the human) can see why the region matters, not just that it does.

3. A contradiction resolved by confidence + source-count weighting
The temporal layer assigns each fact a confidence score, a source_count, and a valid_at timestamp. When two facts about the same entity disagree, find_contradictions surfaces them with both sides’ metadata, and resolve_contradiction picks a winner using the strategy you set.

Two facts both pointing at the same entity (http_transport_port):
{
“fact_a_id”: “e4b2ff84-8c23-4de5-aa9e-8bbb045a4ed5”,
“fact_b_id”: “7fe854f9-d64a-4304-b43a-7d1b126c6ebb”,
“fact_a_text”: “HTTP transport listen port default is 8080”,
“fact_b_text”: “HTTP transport listen port default is 8765”,
“similarity_score”: 0.929,
“both_valid”: true,
“reason”: “same entity, similar text”,
“confidence_a”: 0.7,
“confidence_b”: 0.95,
“source_count_a”: 1,
“source_count_b”: 3
}
resolve_contradiction(strategy=”auto”) picks the strategy with the largest signal gap. Here source count differs 3:1, so it picks keep_most_sources:
{
“strategy”: “keep_most_sources”,
“winner_id”: “7fe854f9-d64a-4304-b43a-7d1b126c6ebb”,
“loser_id”: “e4b2ff84-8c23-4de5-aa9e-8bbb045a4ed5”,
“resolved_at”: “2026-05-21T10:24:16.287368”
}
The loser is updated in place:
{
“id”: “e4b2ff84-8c23-4de5-aa9e-8bbb045a4ed5”,
“fact_text”: “HTTP transport listen port default is 8080”,
“status”: “superseded”,
“invalid_at”: “2026-05-21T10:24:16.285184”,
“confidence”: 0.7
}

Queries that ask “what’s true now?” silently skip the superseded fact. Queries that ask “what was true on 2026-05-18?” still see it. That’s what the temporal layer earns.

4. The PostCompact injection bundle
v0.7.0 added a PostCompact hook that re-injects the top constraints and recent canonical facts after the agent’s context is compacted. The bundle is small (configurable, default ~10 constraints + 10 facts) and prioritized.

The actual bundle returned by get_injection_context(event_type=”PostCompact”, max_constraints=5, max_facts=5):

Active constraints (top by violation count)

  • no-console-log: Use logger.debug() not console.log() in TypeScript source. Production logs route through pino; console.log bypasses formatting and breaks downstream parsers. (violated 5x)
  • check-twine-before-tag: Run python3 -m twine check dist/* before tagging. Catches PyPI metadata errors before the tag is pushed; saves a retraction. (violated 5x)
  • tag-before-upload: Always run git tag + git push –tags before twine upload. PyPI is permanent; an untagged upload pins a wheel to no git ref. (violated 2x)

Recent canonical facts

  • Never run twine upload before git tag. Always tag, push, then upload to PyPI so the published wheel maps to a real git ref.
  • Cursor hooks.json uses object-keyed schema with version: 1 (integer), preToolUse / preCompact / beforeSubmitPrompt event names, failClosed (not fail_open), timeout in seconds.
  • PostCompact and UserPromptSubmit hooks emit additionalContext to splice constraints + recent facts back into agent context after compaction.
  • HTTP transport defaults to port 8765 in Dockerfile.http; do not change without updating docs/deployment/mcp-tunnel.md and docker-compose.yml together.
  • BetaAbstractMemoryTool subclass lives at world_model_server/memory_backend.py; required by the Anthropic SDK Managed Agents memory path.

That bundle is what gets spliced into the agent’s working context as additionalContext after a compaction event. The same query also runs on UserPromptSubmit, biased toward whatever the user just asked about.

The compaction audit log records what happened, queryable via the CLI:

$ world-model audit-compactions –limit 5
1 compaction audit rows
2026-05-21T10:38:01.606771 session=demo-session-1 pre=84320
post=22150 facts_injected=10 constraints_injected=3 event=PostCompact
pre=84320, post=22150 — the compaction dropped ~62k tokens of context. The injection put 10 facts + 3 constraints back. The audit row exists so a human can later answer “what did the agent see vs what did it lose.”

5. A defer decision that pauses a headless agent

v0.7.0 added a defer enforcement tier between deny and warn. Warning-severity violations with violation_count ≥ 5 return permissionDecision: “defer” when the client advertises support, so headless agents pause instead of silently passing or hard-blocking. Clients that do not advertise support fall back to ask automatically.

I have a check-twine-before-tag constraint with violation_count=5, severity=warning. When a Bash tool input matches it, the hook returns:
{
“hookSpecificOutput”: {
“hookEventName”: “PreToolUse”,
“permissionDecision”: “defer”,
“permissionDecisionReason”: “Recurring warning-level violations (check-twine-before-tag). Headless agents should pause for confirmation.”
}
}
Same payload, same constraint, but with supports_defer: false in the request — fall back to ask:
{
“hookSpecificOutput”: {
“hookEventName”: “PreToolUse”,
“permissionDecision”: “ask”,
“permissionDecisionReason”: “Recurring warning-level violations (check-twine-before-tag). Headless agents should pause for confirmation.”
}
}
The defer tier exists because the binary deny / warn choice forces you to either be too strict or too permissive. Recurring warnings that don’t rise to error-level should pause for a human, not block, not pass.

What this means if you are building agents

The reason this works is not that the tool is clever. It is that the substrate — a temporal knowledge graph with facts, constraints, contradictions, and decision traces — captures the right shape of information.

Plain markdown rules in CLAUDE.md cannot answer:

  • How many times has this rule been violated?
  • Which fact is true now vs three sessions ago?
  • Which constraints should I re-inject after compaction?
  • Which prior fix does this proposed change risk re-introducing?

A graph can. The cost is one MCP server, ~2,000 lines of Python, and a SQLite database that sits at ~155 KB empty (mine grew to about 2 MB after running this exercise plus the auto-seed). The payoff is a memory layer that survives compaction, enforces at the edit boundary, and tracks evidence chains back to the source.

If you are building anything with Claude Code, Cursor, or any harness that supports MCP + hooks:

pip install world-model-mcp
cd /your/project
python -m world_model_server.cli setup

For Claude Managed Agents with self-hosted sandboxes (where Anthropic’s built-in Memory primitive is not yet supported), v0.7.2 added streamable HTTP transport so the same 25 MCP tools also work behind an MCP tunnel.

Source: github.com/SaravananJaichandar/world-model-mcp.

If world-model-mcp helped you, star the repo or open an issue with what worked or didn’t. I read every one.

From Prompt Engineering To System Engineering – What Actually Changes In Enterprise AI Systems

yazar

Early AI projects spend most of their time on prompts.

Teams experiment with:

  • wording
  • role instructions
  • formatting
  • temperature
  • examples
  • output structure

And honestly, that works for a while.

You can improve results fast just by changing prompts.

But once AI systems move into enterprise environments, prompt engineering stops being the main engineering problem.

System engineering takes over.

That transition changes almost everything.

Prompt Quality Stops Being The Bottleneck

In small projects, the model is usually the weakest part.

In enterprise systems, the surrounding infrastructure becomes the bottleneck much faster.

The real problems become:

  • inconsistent retrieval
  • workflow orchestration
  • memory synchronization
  • queue reliability
  • latency spikes
  • provider instability
  • deployment safety
  • observability
  • state management

You eventually realize the prompt is only one layer inside a much larger operational system.

And usually not the most fragile layer.

AI Systems Become Stateful Very Quickly

Most teams think they are building stateless AI APIs.

They are not.

The moment you add:

  • conversation history
  • retrieval pipelines
  • agent workflows
  • memory systems
  • tool execution
  • background jobs

you are operating distributed state.

That changes architecture decisions immediately.

One issue we hit recently looked like hallucination from the outside.

The actual problem:

Two workers processed different retrieval snapshots because async state propagation lagged during high traffic.

The model output was logically correct based on stale context.

That is not a prompt problem.

That is distributed systems engineering.

Prompt Engineering Optimizes Output

System Engineering Optimizes Stability

This is the biggest shift.

Prompt engineering asks:

  • How do we improve responses?
  • How do we reduce hallucinations?
  • How do we structure outputs?
  • How do we improve reasoning quality?

System engineering asks:

  • What happens when providers timeout?
  • What breaks during deployment?
  • How do retries affect consistency?
  • How do we recover failed workflows?
  • What happens under traffic spikes?
  • How do we replay failures?
  • How do we isolate corrupted state?

The second category dominates long-term operational work.

Model Providers Become Infrastructure Dependencies

Most early AI applications assume providers behave consistently.

Production systems cannot rely on that assumption.

Things that change unexpectedly:

  • output formatting
  • tokenization
  • tool calling behavior
  • latency
  • moderation layers
  • structured output behavior
  • context handling

A provider-side update can silently destabilize downstream systems.

We started treating model providers exactly like unstable third-party infrastructure.

That changed how we built:

  • validation layers
  • retry logic
  • response normalization
  • fallback systems
  • orchestration rules

Without those protections, small upstream changes leak directly into production behavior.

Orchestration Complexity Grows Faster Than Expected

Simple AI flows are manageable:

Input → Prompt → Response

Enterprise systems rarely stay simple.

Now you have:

  • retrieval pipelines
  • embedding generation
  • vector search
  • memory updates
  • multi-agent coordination
  • async execution
  • external integrations
  • workflow branching

The orchestration layer eventually becomes larger than the prompt layer itself.

And debugging becomes much harder.

One failed workflow may involve:

  • queue systems
  • multiple services
  • retrieval failures
  • stale memory
  • provider retries
  • partial execution recovery

At that point, system design matters more than prompt wording.

Observability Changes Completely

Traditional backend monitoring is not enough for AI systems.

A healthy API does not mean healthy reasoning.

You need visibility into:

  • prompts
  • retrieval documents
  • token usage
  • orchestration timing
  • memory mutations
  • tool execution
  • provider latency
  • model outputs

Otherwise debugging becomes impossible.

One thing we now consider mandatory:

Full execution replay.

Not logs alone.

Complete reconstruction of:

  • inputs
  • retrieval state
  • prompt versions
  • tool outputs
  • model responses
  • workflow decisions

Because AI failures are often non-deterministic.

Without replayability, debugging becomes guessing.

Reliability Starts Beating Intelligence

This is where enterprise priorities shift hard.

During experimentation, teams optimize for:

  • smarter outputs
  • better reasoning
  • more capable agents
  • larger context windows

In production, priorities change:

  • stable execution
  • predictable behavior
  • recoverability
  • operational visibility
  • cost control
  • deployment safety
  • consistency under load

A slightly weaker system that behaves predictably is usually more valuable than a highly capable unstable one.

The Biggest Change

The biggest change is realizing that enterprise AI systems are not model problems anymore.

They are infrastructure problems.

The prompt still matters.

But long-term success depends far more on:

  • orchestration
  • reliability
  • state consistency
  • observability
  • operational tooling
  • deployment safety
  • failure recovery

The model is only one moving part.

The infrastructure around it determines whether the system survives production.

I Built a Habit Tracker That Actually Made Me Want to Use It

yazar

Most productivity apps I’ve tried have one thing in common: they’re exhausting to look at.

Too many features. Too many tabs. Too many “just set up this workflow and you’ll be productive in no time” promises. After a week I’d stop opening them, and then feel guilty every time I saw the app icon.

So I built Improve You — a ruthlessly minimal daily habit tracker with a built-in Pomodoro focus timer. No task lists. No project boards. Just your core habits and a timer to actually do the work.

Here’s what I learned building it.

The Problem I Was Solving (For Myself)

I didn’t want to track everything. I wanted to track the 5 things that, if I do them every single day, compound into a radically better version of me over a year.

  • Drink 2L water
  • Read 20 pages
  • Work out 45 minutes
  • 2 hours of deep work
  • Whatever else matters to you

That’s it. No backlog. No overdue tasks. Every morning the slate resets automatically, like a daily ledger. You either did the work or you didn’t. No excuses.

The Features That Actually Mattered

1. Persistent Core Habits

Habits live at the identity level. You set them once, and they appear every morning without you doing anything. No creating a new “task” every day. The system respects that these habits are who you are, not items on a to-do list.

2. Deep Work Focus Mode

A fullscreen Pomodoro timer that strips away every distraction. When you enter Focus Mode, nothing else exists. The hours you log here are tracked separately — so you can actually see how much real work you’re doing versus how much you’re just busy.

This was the feature I personally needed most. It’s one thing to check off “deep work” as a habit. It’s another to see that you only actually focused for 40 minutes today instead of the 2 hours you told yourself you’d do.

3. XP, Levels & Streaks

I know, gamification gets a bad rap. But here’s the thing — it works on me.

Every completed habit earns XP. Every minute in focus mode earns XP. You level up. You unlock badges. You have a streak to protect.

The streak psychology is real. “Don’t break the chain” is one of the most powerful motivators for daily behavior. The app leans into it hard.

4. Global Leaderboard (Pro)

This one surprised me — seeing your name on a leaderboard next to other people who are also grinding daily habits is oddly motivating. It makes discipline feel like a team sport.

What I Intentionally Left Out

No subtasks. No priority levels. No “snooze until tomorrow.” No recurring task templates with complex scheduling.

Every feature I considered adding, I asked: does this make it easier to do the work, or just easier to feel like I’m planning to do the work?

If the answer was the latter, it didn’t ship.

The Free vs Pro Decision

Free tier: track up to 5 habits, streak tracking, focus mode, XP & badges. Forever.

The free tier is genuinely useful — 5 habits is actually the right number for most people starting out. Pro unlocks unlimited habits, analytics (30-day consistency rate, longest streaks), the global leaderboard, and priority support.

I wanted the free tier to feel complete, not crippled. Nobody should have to pay just to use the core loop.

What’s Next

  • Mobile app (PWA first, then native)
  • Weekly reflection prompts
  • Habit templates for common goals (fitness, reading, creative work)
  • API for nerds who want to integrate it with their own dashboards

Try It

If you’re the kind of person who believes the quality of your life is determined by the quality of your daily habits — Improve You was built for you.

5 habits, free, forever. No credit card. No onboarding wizard. Just open it and start.

Built by Ashutosh Swamy — GitHub · LinkedIn