Day 9 of the 30 Days of AWS Terraform series focuses on Terraform Lifecycle Rules — powerful controls that decide how Terraform creates, updates, replaces, and destroys resources. What Terraform LifeCycle meta arguments are Lifecycle meta arguments allow us to control how Terraform behaves when it creates, updates, or destroys resources. They help us: Avoid downtime Protect important resources Handle changes made outside Terraform Validate configurations before and after deployment Enforcing compliance Controlling replacement behavior Lifecycle rules allow us to override default behavior safely. Lifecycle rules are Terraform-native controls applied inside a resource block: lifecycle { ... } Lifecycle Rules Covered 1️⃣ create_before_destroy — Zero Downtime Updates Problem: Terraform destroys the old resource before creating the new one → downtime. Solution: lifecycle { create_before_destroy = true } Behavior: New resource is created first Old resource is destroyed only after Ensures zero downtime 2️⃣ prevent_destroy — Protect Critical Resources This setting prevents Terraform from deleting a resource. Example If Terraform tries to destroy this resource, it will fail with an error. This is useful for: Production databases State storage buckets Important data resources 3️⃣ ignore_changes — Allow External Modifications Problem: Terraform overwrites manual or automated external changes. Solution: lifecycle { ignore_changes = [desired_capacity] } Demo: Auto Scaling Group desired capacity modified manually in AWS Console terraform apply did not revert the change Behavior: Terraform ignores changes for specified attributes. ✅ Use for: Auto Scaling Groups Resources modified by external systems Ops-driven configurations 4️⃣ replace_triggered_by — Replace When Dependency Changes Problem: Changing a dependency doesn’t always recreate dependent resources. Solution: lifecycle { replace_triggered_by = [aws_security_group.main] } Behavior: When security group changes EC2 instance i

In the world of project management and team collaboration, the holy grail is reducing friction. Previously, we looked at how to make Trello cards talk back The Power of Gemini inside Trello and how to bring Gemini into your workspace Gemini in your Slack workspace . But what if you wanted a highly intelligent, stateful team assistant living directly in Slack that could answer complex, open-ended questions about your Trello boards? Questions like: "Which cards did I edit last week?" "Show me all comments made across my active boards in the last 7 days." "What is the current status of the card XYZ?" Answering these questions requires more than simple semantic search; it requires a tool that can dynamically write retrieval scripts, parse complex multi-board JSON payloads, filter dates, and compile elegant reports. In this article, we'll explore how to build exactly that using Google’s Antigravity Managed Agent (the "Agy" agent) , integrated into Slack's native Agent View , utilizing a secure, stateful, and sandboxed remote execution environment. 🚀 Prerequisites Before starting, make sure you have: A Google AI API Key with Gemini / Antigravity access A Trello Account (with an API Key and Token for read-only board queries) A Slack Workspace (with App Admin privileges to create a Socket Mode app) Node.js (v24+) and pnpm (v11+) installed 🔒 Security & Environment Controls: The Agy Sandbox Philosophy At the heart of this setup is Google's Antigravity (Agy) Managed Agent . Instead of running in a transient stateless environment, the Agy agent operates inside a persistent, secure, and remote Linux sandbox equipped with standard execution engines (Python, Node.js, bash, etc.). When a Slack user asks a question, the Agy agent dynamically writes a script, runs it in its isolated sandbox, inspects the Trello API output, self-corrects if any errors occur, and presents a formatted response. In this article, we focus on Trello, but the same principles can be applied to any other syst

Catch API drift before your customers do Discussion | Link

I initially wanted to **make a side-scrolling game like MapleStory**. YouTube was flooded with "I made a game with AI (Claude)," so I thought it would be easy. But when I tried it myself – it turned out that **people with existing game development knowledge were just using AI to improve quality and speed**, not that you could just "make it for me" without any knowledge. In the end, what I completed wasn't a playable game, but an **"auto-battle" spectator game** (like raising a mushroom) that you just watch. This post is about that **honest journey** – where I got stuck, why I pivoted, and what I learned. (And you can try out the completed version via the **🎮 Play Now** link below.) I'm a developer in Korea building an AI chatbot alone. I only write about things I've **actually tried and experienced**.## 1. The First Wall — AI-Generated Characters Can't 'Walk' **Moving characters** are essential for games like MapleStory. So, I first tried **AI image generation (gpt-image) to create chibi characters** and then generated walk cycles (4 frames of walking animation) for them. This is where I got stuck. **With each frame, the character subtly became a different character** – the color of the clothes, the proportions, the face all changed slightly between frames 1, 2, 3, and 4. When stitched together in a game, the character wouldn't walk; it would just **tremble erratically.** The Ceiling of Character Animation — AI Generation vs. Pre-made Sprites ❌ AI-Generated Characters (Re-imagined each frame) 🧍1 🧎2 🕴️3 🧍4 → Clothing/proportions wobble each frame = 'Trembling' instead of walking ✅ Pre-made CC0 Sprites (Hand-drawn sheet) 🏃1 🏃2 🏃3 🏃4 → Consistent frames = Smooth walk cycle This is **exactly the same ceiling** I hit in Making AI Videos (Dev Log #3) – AI image generation **cannot create consistent character animation (multi-frame movement).** The same wall in videos, the same wall in games. 2. Pivot ① — Abandoning AI Characters for Pre-made Sprites So, my first surrender

The company is raising $10 billion, leading to a valuation of $130 billion.

Quantum mechanics gave us the transistor before we understood it. The same pattern is happening with AI right now — and the builders who recognize this will define what comes next. The argument that never ended — and the lab that didn't care In 1927, the greatest minds in physics gathered in Brussels for the Solvay Conference. Albert Einstein, Niels Bohr, Werner Heisenberg, Erwin Schrödinger, Max Planck, Marie Curie — twenty-nine of the most brilliant humans who ever lived, in one room. They were arguing about quantum mechanics. Specifically: what does it mean for a particle to exist in multiple states simultaneously until observed? Does reality require an observer? Is the universe fundamentally probabilistic? Is God playing dice? Einstein said no. Bohr said yes. Neither convinced the other. That argument never fully resolved. Nearly a century later, physicists still debate the interpretation of quantum mechanics — the Copenhagen Interpretation, Many Worlds, Pilot Wave theory. We have not settled it. Meanwhile, in 1947 — twenty years after the Solvay Conference — three engineers at Bell Labs in New Jersey quietly invented the transistor. William Shockley, John Bardeen, and Walter Brattain did not wait for the philosophical debate to conclude. They did not need to understand why quantum tunneling worked at a fundamental level. They understood it well enough to build something with it. That transistor became the foundation of every computer, every smartphone, every server, every piece of digital infrastructure that exists today. We built the entire digital civilization on something we still don't fully understand. Not despite the uncertainty. With it. The pattern repeating right now Across the internet in 2025 and 2026, a remarkably similar argument is happening. Will AI take all the jobs? Is it conscious? Does it hallucinate too much to be trusted? Are we building something we cannot control? Should we slow down? Should we stop? These are not trivial questions. The r

If you've been monitoring Linux servers for any length of time, there's a good chance node_exporter was the first thing you installed. It's lightweight, reliable, and exposes a huge amount of machine metrics for Prometheus to scrape. For years, it has been the default answer. As your infrastructure grows, though, your monitoring stack usually grows with it. First comes log collection. Then traces. Before long you're running node_exporter , a log shipper, and maybe another telemetry agent. Each component has its own configuration, service unit, upgrade cycle, and failure modes. Grafana Alloy changes that by consolidating those responsibilities into a single telemetry agent. This post walks through migrating from node_exporter to Alloy on a real fleet, one server at a time, while maintaining continuous visibility throughout the process. These are the exact steps that survived contact with production on the Irin monitoring stack, not the idealized version that looks clean in a diagram. TL;DR If you're already running node_exporter , don't replace it overnight. Install Grafana Alloy alongside it, configure Alloy's built-in prometheus.exporter.unix component, verify that metrics are reaching your remote Prometheus instance, and only then retire node_exporter. Migrating one server at a time minimizes risk, preserves visibility, and positions your infrastructure for logs, traces, and future telemetry without deploying additional agents. The real difference is the direction of travel Before getting started, it's worth understanding what actually changes. This isn't simply replacing one monitoring agent with another. node_exporter is a server. It listens on a port, typically 9100,and waits for Prometheus to connect and scrape metrics. That means every monitored machine needs an open endpoint, network connectivity from Prometheus, firewall rules, and scrape configurations. Alloy flips that model around. Instead of waiting for Prometheus to connect, Alloy collects metrics loca

🎯 Learning Objectives Understand the interface boundary between Terminal Emulators and Shell Interpreters (including Windows Terminal vs. PowerShell vs. CMD). Master File System path tracking, hidden dotfiles, and essential CLI utilities. Map system execution paths via global and local environment configurations. 1. Terminal vs. Shell (The Windows Architecture) Terminal: The visual GUI wrapper. A window application that captures keyboard strokes, handles GPU text rendering, and manages tabs/panes. Examples: Windows Terminal, iTerm2, Alacritty. Shell: The command interpreter engine running inside the terminal. It evaluates text strings, processes scripts, issues system calls ( syscalls ), and interacts with the OS Kernel. Examples: PowerShell, Bash, Zsh, Command Prompt (CMD). ┌────────────────────────────────────────────────────────┐ │ WINDOWS TERMINAL GUI (The Visual Interface Window) │ │ │ │ │ ├───► Tab 1: [ PowerShell Core Engine (Modern) ] │ │ ├───► Tab 2: [ Command Prompt Engine (Legacy) ] │ │ └───► Tab 3: [ WSL Ubuntu Linux Bash (Core) ] │ └───────────────────────────┬────────────────────────────┘ │ Raw Text & Input Streams ▼ ┌────────────────────────────────────────────────────────┐ │ SHELL INTERPRETER (e.g., PowerShell / CMD) │ │ └───► Parses input string commands into system tasks │ └───────────────────────────┬────────────────────────────┘ │ System Call (Syscall) ▼ ┌────────────────────────────────────────────────────────┐ │ OPERATING SYSTEM KERNEL │ │ └───► Interacts directly with underlying hardware │ └────────────────────────────────────────────────────────┘ 2. Deep Dive: PowerShell vs. Command Prompt (CMD) While both are Windows shells hosted inside Windows Terminal, they belong to entirely different computing eras: Command Prompt ( cmd.exe ): A legacy text shell maintained purely for backwards compatibility with 1980s MS-DOS. It pipelines data as Plain Text Only , meaning outputs must be manually string-filtered. PowerShell ( pwsh.exe ): A modern, cros

Artificial intelligence has become one of the most discussed technologies in education. From automated grading systems to AI chatbots capable of answering complex questions, many people wonder whether AI will eventually replace teachers. The short answer is no. Education has never been just about delivering information. Great teachers inspire curiosity, understand students' emotions, adapt to different learning styles, and create environments where learners develop critical thinking. These are deeply human abilities that artificial intelligence cannot fully replicate. However, AI is beginning to solve a different problem: helping students learn independently outside the classroom. The Problem With Traditional Self-Study Many students spend hours reading textbooks without truly understanding the concepts. When they encounter a difficult paragraph, they often search the internet, only to find lengthy articles, conflicting explanations, or answers that are either too advanced or completely unrelated to their curriculum. This creates an inefficient learning process where students spend more time searching than actually learning. Another common challenge is passive learning. Reading a chapter once often creates the illusion of understanding, but without testing knowledge through questions or applying concepts, much of that information is quickly forgotten. How AI Can Support Learning Modern educational AI systems are becoming less like search engines and more like interactive learning companions. Instead of simply returning search results, these systems can explain concepts in simpler language, adapt explanations to a student's academic level, answer follow-up questions, generate practice quizzes, and even identify areas where additional practice is needed. This creates a much more personalized learning experience. Learning From Personal Study Materials One of the most interesting developments in AI education is the ability to work with a student's own resources. Rather

Enterprises are now talking about AI coding agents in a very predictable way. The first question is usually: "How much more code can it help us generate?" It is not a wrong question. But if that is the only question, the ROI calculation will probably be wrong. Because enterprises are not really buying "more code." They are buying: faster delivery less rework lower maintenance cost better developer experience more stable software quality more controllable security and compliance risk faster translation from product capability to business value Code generation is an input. It is not the outcome. That distinction matters. An AI coding agent can help developers write functions, fix bugs, add tests, generate documentation, understand codebases, and refactor legacy systems. That sounds powerful. But the enterprise question is not: "How many lines of code did it generate today?" The better question is: Did that code reach production faster? Did incidents go down? Did the team spend less time on repetitive work? Did customers get value sooner? If the answer is unclear, generating 100,000 lines of code a day may simply mean producing technical debt faster. The short version: AI coding agent ROI does not end inside the IDE Many teams start measuring AI coding tools with the most obvious numbers: code suggestion acceptance rate lines of code generated number of active users number of prompts time saved on individual tasks These metrics are useful. But they mostly show that the tool is being used. They do not prove that the enterprise is getting value. Enterprise ROI has to be measured across software delivery, quality, risk, and business outcomes. In other words, an AI coding agent is not just a point solution for individual efficiency. It affects the entire software value stream: Request -> Design -> Coding -> Review -> Testing -> Deployment -> Monitoring -> Feedback -> Business outcome If you calculate value only inside the "coding" box, you miss the bigger picture. Why "amo

Git submodules have a reputation for being fiddly, but most of that pain comes down to a handful of missing commands and one config flag nobody mentions. Used well, they're a clean way to embed a shared library, a design-system repo, or a common docs folder inside another project - pinned to an exact commit so nothing shifts under your feet. This guide walks through the whole lifecycle, from adding a submodule to removing it, and calls out the gotchas that bite teams in real projects. Understanding What a Submodule Actually Is Before the commands, one mental model that clears up most confusion: a submodule embeds another git repo inside yours at a fixed path, pinned to a specific commit. Your repo doesn't track the submodule's files - it tracks which commit of the submodule to check out. That single idea explains almost every quirk that follows. Adding a Submodule Adding one is a single command: git submodule add git@github.com:org/shared-lib.git vendor/shared-lib This clones the repo into vendor/shared-lib , creates a .gitmodules file describing the mapping, and stages the pinned commit (git calls this a "gitlink"). Commit both pieces: git add .gitmodules vendor/shared-lib git commit -m "chore: add shared-lib submodule" The resulting .gitmodules entry is plain text and lives in version control: [submodule "vendor/shared-lib"] path = vendor/shared-lib url = git@github.com:org/shared-lib.git branch = main The branch line is optional: it's only used later when pulling the latest changes automatically. Cloning Without the Empty-Folder Surprise The most common submodule complaint is a teammate cloning the project and finding an empty folder where the submodule should be. The fix is knowing two commands: # Clone everything in one shot git clone --recurse-submodules <your-repo-url> # Already cloned? Initialize after the fact git submodule update --init --recursive Even better, run this once per machine so git pull and git checkout keep submodules in sync automatically - a

Why I Choose Lovable for Building Full-Stack Applications with AI Over the last year, AI-assisted software development has evolved from generating code snippets to building complete web applications. We've all seen tools like Cursor, Claude Code, GitHub Copilot, Replit Agent, Bolt, and many others enter the market. Each has its strengths, but after experimenting with several of them, I keep coming back to Lovable whenever I want to build a new web application from scratch. This isn't a sponsored post—it's simply the workflow that has worked well for me. If you're interested in trying Lovable, you can use my referral link below. Disclosure: new users receive additional signup credits, and I receive referral credits if you sign up through it. Referral: https://lovable.dev/invite/AQ02SOZ Why Lovable Stands Out Most AI coding assistants help you write code. Lovable helps you build an application. Instead of focusing on individual functions or files, it takes a higher-level approach where you describe what you want, and it generates a complete full-stack application that you can continue refining. A typical workflow looks like this: Idea │ ▼ Describe the application │ ▼ Lovable generates • Frontend • Backend • Database • Authentication • API integration │ ▼ Preview instantly │ ▼ Connect GitHub │ ▼ Iterate and Deploy Unlike traditional no-code platforms, you're not locked into a proprietary editor. Lovable supports GitHub synchronization, native Supabase integration for authentication and PostgreSQL-backed data, and deployment options ranging from Lovable-hosted apps to your own infrastructure. Why I Keep Choosing Lovable After building several side projects, these are the reasons I continue to use it. 1. Rapid idea-to-production workflow The biggest productivity gain isn't AI-generated code. It's reducing the number of decisions needed before users can interact with your application. Instead of spending hours creating project structure, authentication, routing, database

You start the morning with four Claude Code agents running, each in its own git worktree, each on a separate task. By mid-afternoon something is off. One agent has re-implemented a helper another already wrote. A second built against an interface that a third changed an hour ago. A fourth made a naming choice that contradicts a decision you made — out loud, to yourself — at 9am. Every diff is reasonable on its own. The system they add up to is not. This is the failure mode that shows up the moment you go from one agent to several. The code each agent produces is fine. What drifts is everything between the agents: the decisions, the conventions, the current shape of the interfaces they all depend on. Running the agents in parallel is the easy part. Keeping them coherent is the hard part, and it's a different problem. Why parallel agents drift An agent's context is per-session. Each Claude Code instance has its own context window, populated by what it has read and done in that session. Nothing about that window is shared with the agent running in the next worktree. There is no common memory they all write to and read from. So when agent A decides "we use the repository pattern for data access," that decision exists in exactly two places: agent A's context, and your head. Agent B never hears about it. Three kinds of state cause the drift, and they're worth separating because they need different handling: Decisions already made. Architecture, naming, conventions, the approach you settled on for a cross-cutting concern. These are durable — once made, they should bind every agent, including ones you spawn tomorrow. The current contract. The shape of the interfaces, types, and APIs that agents share. This changes during the work: agent A edits a signature, and agents B and C are now building against a version that no longer exists. What's in flight. Who is touching which files right now. Two agents editing the same module in separate worktrees won't see each other until th

New tech has changed the game with the latest generation of pickleball paddles. Here's what to know and what to buy.

A cybersecurity startup dangling millions of dollars to acquire zero-day security vulnerabilities in popular software is run by a pair of far-right conspiracy theorists and convicted felons whose most recent ventures included fake intelligence companies and a now-defunct AI-based lobbying platform they operated under assumed names.

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. Why worms (and microbes) are catching on as a manure pollution solution Anthony Agueda, a third-generation California dairy farmer, pulls a rake through a bed of dark, wet wood chips to…