标签：#dev

The Comfort Zone Trap Most developers hit a point where they know enough to be productive, and then... stop growing. You can build features, fix bugs, ship code — and still be standing still. The comfort zone doesn't feel like stagnation. It feels like competence. This is one of the sneakiest traps in a dev career. Early on, growth is forced on you — every new project throws unfamiliar problems your way, and you have no choice but to learn. But once you've built a solid mental toolkit (a stack you're comfortable in, a set of patterns that "just work"), it becomes very easy to keep reaching for the same tools on every new problem. You're productive. You're shipping. And you're not actually getting better. The danger is that this plateau is invisible from the inside. Nobody sends you a notification saying "you've stopped growing." You just keep doing what you know, at the same level, for years — until you compare yourself to someone who deliberately kept pushing, and the gap feels much bigger than it should. Why "Just Keep Coding" Doesn't Work The common advice is to just build more projects. But volume without friction doesn't teach you much — repeating the same patterns on new ideas just reinforces what you already know. Growth comes from deliberately picking problems slightly outside your current skill ceiling, not from doing more of what's comfortable. Think about it like weightlifting. If you lift the same weight every session, you get very good at lifting that exact weight — and nothing more. Progressive overload works because you're constantly pushing slightly past your current limit. Coding is the same. If every project you build uses the same stack, the same architecture patterns, and the same problem shapes, you're doing bicep curls with the same 10kg dumbbell for five years straight. The fix isn't "build more" — it's "build harder." Pick a project that forces you to learn a new paradigm (functional if you're used to OOP, distributed systems if you've only b

TL;DR It's been a while since I've done a collection (maybe month ago), but today let's look at 12 new and not-so-new projects that can really help you in development. They touch on different areas of development, but we will mainly talk about web development. If there's a project worth adding to the next collection, feel free to write about it in the comments, and maybe it will be included. 1. 🤖 OpenWork - The open source Claude Cowork alternative. And we will continue, of course, with AI projects. This tool will allow you to work in one convenient interface with many popular LLMs. OpenWork is the desktop app that lets you use 50+ LLMs. 💎 Check out the OpenWork repository ☆ 2. 💻 T3 Code - The open-source control plane for coding agents. If you know a YouTuber like Theo, then you should know this project. It's an OpenCode alternative that lets you work with AI in an easy-to-use chat interface. It enables control of the agents on your machine with a best-in-class mobile app (iOS, Android), web app and Electron-based desktop app. 💎 Check out the T3 Code repository ☆ 3. ⚙️ Summarize - Point at any URL or file. Get the gist. The first project is a small tool for extracting short info of content. Summarize was created by one of the creators of the well-known OpenClaw. Fast summaries from URLs, files, and media. 💎 Check out the Summarize repository ☆ 4. 👾 Godot - Free and open source 2D and 3D game engine A truly legendary engine like Unity or Unreal Engine for games. If you are a game developer, you should know this project. From pet projects for the university to multi-million dollar games - it gives it all. Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. 💎 Check out the Godot repository ☆ 5. 💎 React Bits - An open source collection of animated, interactive & fully customizable Rea

An agent patch is only as trustworthy as the checks it cannot rewrite. If properties, fixtures, and flake policy live in the same tree as src/ , the diff can weaken the proof. Move the oracle out of the writable tree and run it as a control loop with hysteresis, not as a skip list. Co-located tests fail this requirement in a predictable way. The agent adds an assertion that matches the new code. A fixture grows a default that hides a broken parser. A flaky case becomes skip . The suite stays green. Production still drifts. This article proposes a sidecar oracle: human-owned properties, sealed fixtures, and a two-threshold flake freeze. The design is a workflow, not a production case study. Treat the code as a proposed runner you can execute locally, not as a claim about a live fleet. What the loop decides The loop answers three questions on every candidate patch: Do independent properties still hold on generated inputs? Did the patch mutate a sealed fixture or depend on an unsealed one? Is a failing test a regression, or does it belong in a measured freeze? A skip list answers none of those. It only records that someone got tired of a red job. Layout: oracle beside the repo, not inside the diff Keep the application repo writable for the agent. Keep the oracle in a second directory that the agent cannot include in its patch. app/ # agent may write src/, not oracle paths src/ pyproject.toml oracle/ # human-owned; hashed before every gate properties/ test_invariants.py fixtures/ manifest.json http_empty_body.json flake_ledger.json path_deny.txt run_gate.py path_deny.txt is the first control, not the last. If the patch touches oracle files, tests the agent authored, or lockfiles it did not need, the gate fails before pytest starts. # oracle/path_deny.txt oracle/ **/test_*.py **/*_test.py **/conftest.py **/__snapshots__/ The deny list is deliberately blunt. Agent-authored tests can still exist as scratch. They do not count as evidence. Step 1 — Hash the oracle before the

Every developer I know now runs an AI coding agent in something like auto-accept mode. Claude Code, Codex, Cursor: you give it a task, it runs commands, edits files, installs packages, and you review... the diff, maybe. The commands? The installs? The thing it did in that folder outside the repo? Nobody looks. The activity scrolls off the terminal and is gone. That asymmetry bothered me. We built an entire industry around audit trails for humans (git blame, CI logs, access logs), then handed the keyboard to agents and kept none for them. So I built Tracon: a local flight recorder for AI coding agents. The name is the FAA's term for Terminal Radar Approach Control, the radar room that tracks every aircraft in an airspace. This one tracks every agent on your machine. What it does Tracon is a Mac and Windows desktop app (Tauri 2, Rust core, React UI, SQLite store) that sits in the tray and records what your agents do: A timeline per session: every command, file edit, package install, and prompt, attributed to the agent and session that did it Danger flags as they happen: recursive deletes, pipe to shell installs, credential access, force pushes, permission bypasses. Tracon flags; it never blocks A Live page: one monitor per active session, like a security room, streaming recent commands with flagged ones highlighted in red, plus which subagents the session has spawned A conversation reader: the actual chat behind any event, read straight from the agent's own transcript, read only A package watch across npm, pnpm, pip, cargo, and brew, with opt in threat intelligence against osv.dev Capture is deliberately passive. Hooks give real time events over localhost; transcript tailing (filesystem notify, read only) covers everything else, so CLI sessions show up live even with zero setup. A dead or closed Tracon never slows an agent down. Everything stays on your machine: no telemetry, no accounts, AGPL. The recursive part Here is the part I find genuinely funny: Tracon was lar

If you work with Java/JDBC long enough, you eventually run into this situation: You have code like this: String sql = "SELECT * FROM users WHERE id = ? AND status = ?" ; PreparedStatement pst = con . prepareStatement ( sql ); pst . setLong ( 1 , userId ); pst . setString ( 2 , status ); And then, from a log or debugger, you know something like: userId = 42 status = ACTIVE But what you actually need is the SQL you can paste into your database client: SELECT * FROM users WHERE id = 42 AND status = 'ACTIVE' ; Doing this once is trivial. Doing it repeatedly while debugging production issues is annoying. It gets worse when: the SQL is split across several Java strings; values come from map.get("KEY"); there are dates or timestamps; strings contain apostrophes; some parameters are unresolved; the method contains several PreparedStatements. I kept doing this manually, so I built a small tool called Bind2SQL. What it does Bind2SQL takes Java/JDBC code and reconstructs the executable SQL. For example: String sql = "SELECT * FROM person " + "WHERE person_id = ? " + "AND type_id = ? " + "AND created_at >= ?" ; PreparedStatement pst = con . prepareStatement ( sql ); pst . setLong ( 1 , values . get ( "PERSON_ID" )); pst . setInt ( 2 , values . get ( "TYPE_ID" )); pst . setDate ( 3 , Date . valueOf ( "2026-09-02" )); With runtime values: {PERSON_ID=12648350, TYPE_ID=29} It produces something like: SELECT * FROM person WHERE person_id = 12648350 AND type_id = 29 AND created_at >= DATE '2026-09-02' ; The important part is that unresolved parameters are not silently guessed. If Bind2SQL cannot resolve something, it leaves it clearly marked so you can review it manually. Why I made it browser-only I often use this kind of tool with real application code and runtime values. That may include: internal SQL; identifiers; production log values; table names; application-specific data. So I didn't want a server in the middle. Bind2SQL runs entirely in the browser. There is: no backend; no

You know this loop. A page feels slow. You open the Lighthouse panel in DevTools, hit Analyze, and get 86 . You change nothing, run it again, and get 91 . You run it a third time out of spite: 78 . Now which number goes in the PR description? This isn't a bug. Total Blocking Time is CPU-sensitive and worth roughly 30% of the Performance score, so anything else your laptop is doing — a Slack notification, a Docker build, Spotlight reindexing — moves the number. Lighthouse Performance realistically swings about ±5 points on identical runs of an identical page. One run is an anecdote. And the tool that would give you a stable, real-world answer — PageSpeed Insights — needs a public URL, so it can't audit the thing you're actually working on. I got tired of this and built LightAudit Score : a local console that runs Lighthouse on your own machine, repeats it enough times to mean something, and keeps the results. It's free. Not "free tier" — free, MIT, no account, no usage cap. The three gaps, concretely 1. Reach: PSI needs a public URL, your work isn't public PageSpeed Insights is excellent and I use it constantly. It also cannot audit: localhost:3000 , which is where the change you just made lives a staging box behind a VPN the internal app that nobody can link to a preview deploy that dies in an hour The usual workaround is a tunnel, or "we'll check it after deploy," which means checking it after it's a problem. LightAudit runs the same Lighthouse v13 engine against your own Chrome. If your browser can open it, LightAudit can audit it — localhost, staging, VPN, intranet, all through exactly the same pipeline. 2. Accuracy: make the number boring This is the part I care about most, because a score you can't reproduce is a score you can't act on. Median of N. Every URL is audited N times (default 3), and Lighthouse's own computeMedianRun picks the representative run. Not the average — the actual median run, with its real trace. Isolated Chrome per run. Every run launches

If you use Cursor or Claude Code heavily, you probably know this workflow: You start a new session, drag and drop a bunch of UI screenshots, architecture diagrams, or heavy project specs into the chat, and tell the AI to look at this. It works, but it causes two massive problems: Token Burn (and Credit Drain): Vision tokens and heavy text files are expensive. You waste your API credits processing those same screenshots and docs every single time you spin up a new chat. Context Clutter: The AI's context window gets clogged. Its logic degrades because it’s carrying all that heavy media and text around in its short term memory. I got tired of burning through my API credits on this daily, so I started looking into the Model Context Protocol (MCP). Why MCP is the answer Instead of dumping static files and images directly into the prompt, MCP allows your AI editor to query a local or remote server only when it needs specific information. Think of it like giving Cursor a direct database connection to your project's assets. It indexes the data once, and the AI retrieves just the pieces it needs to answer your specific coding question. The token savings are ridiculous. How I automated this (Building Dokpod) You can build a local MCP server yourself, but managing the indexing for mixed media (images, video walkthroughs, and text), handling local environments, and keeping connections stable became its own headache. So, I built [Dokpod.io] to automate the entire thing. It acts as an AI knowledge vault. You upload your UI screenshots, video walkthroughs, API docs, and codebase context into Dokpod once. It handles the indexing and gives you a simple MCP connection to plug straight into Cursor or Claude. The result: Zero repetitive uploading for images, videos, or text. Massive reduction in input tokens (saving your credits and limits). The AI actually remembers your UI references and architecture across different coding sessions. I need your technical feedback If you are wrestlin

What a "production-ready" FastAPI starter actually needs Every FastAPI project I've started begins the same way: an hour of boilerplate before I write a single line of actual logic. Auth. A database session dependency. A folder structure that won't fall apart once there's more than one resource. A test setup that doesn't take longer to configure than the tests themselves. I got tired of rebuilding it, so I built it once, properly, and wrote down why each piece is shaped the way it is. The structure Every resource in the project follows the same four layers: Router — HTTP in/out only. Parses the request, calls a service, serializes the response. No business logic lives here. Service — business rules. Ownership checks, "does this already exist" decisions, orchestration. No FastAPI imports — this layer doesn't know it's running inside a web framework. Repository — persistence only. SELECT/INSERT/UPDATE/DELETE via SQLAlchemy. No business rules. Schema — Pydantic models for request/response shapes, kept separate from the ORM models. This feels like overkill for a single resource. It stops feeling that way the first time you need the same ownership check enforced in two different routes, or the first time you want to unit-test a business rule without spinning up the whole ASGI app to do it. The decisions that actually mattered Testing against real Postgres, not SQLite. A SQLite-backed test suite gives you false confidence — native UUID types, enum handling, and constraint behavior all differ enough that "tests pass" stops meaning "the Postgres-specific code works." Each test runs inside a SAVEPOINT that gets rolled back afterward, so isolation doesn't cost a schema rebuild per test. Two token types, not one. Short-lived access tokens (15 min) plus longer-lived refresh tokens (30 days), with the token's type claim checked on every decode — a refresh token presented where an access token is expected gets rejected on that alone, not just on signature validity. One error shap

JavaScript Functions and Hoisting Functions are one of the most important concepts in JavaScript. A function is a reusable block of code that performs a specific task. JavaScript provides different ways to create functions, such as: Function Declaration Function Expression Arrow Function IIFE These functions can behave differently when hoisting is involved. What is Hoisting in JavaScript? Hoisting is the behavior where JavaScript processes declarations before executing the code. For example: console . log ( name ); var name = " Abishek " ; Output: undefined This happens because the var declaration is processed before execution. We can think of it like this: var name ; console . log ( name ); name = " Abishek " ; Notice that only the declaration is processed early. The value "Abishek" is assigned later. Hoisting does not physically move the code to the top. The same concept also applies to functions, but the behavior depends on how the function is created. What is a Function? A function is a reusable block of code that performs a specific task . Example: function greet () { console . log ( " Hello " ); } greet (); Output: Hello Here: function greet() → function declaration greet() → function call We can call the function whenever we need it. 1. Function Declaration A function declaration is the normal way of creating a function. greet (); function greet () { console . log ( " Hello " ); } Output: Hello Why does this work? Because function declarations are fully hoisted . JavaScript makes the function available before executing the code. Hoisting Rule Function declarations can normally be called before their declaration. Example: greet (); function greet () { console . log ( " Hello " ); } ✅ Works. 2. Function Expression A function expression is a function stored inside a variable. const greet = function () { console . log ( " Hello " ); }; greet (); Here: const greet is a variable, and the variable stores a function. Now look at this: greet (); const greet = function

Harness looks cool, yeah! I know its origin, its role in Testing, and why. But that's exactly what throws you off, the story you're expected to defend. There's something deeper. I opened my session with "hi", expecting my forced load via CLAUDE.md and my contract as always, and today, out of nowhere, the model suggested two services that needed my authorisation. Microsoft 365 and Zapier. I don't have, and never wanted, them authorised. I never asked for them. And here's the part that pisses me off: I went to check. And... I look on my machine and find nothing. No config, no credential, no trace. I look in the online settings and see them listed as suggestions, like the trending product (connector) of the moment sitting in the prime spot on a supermarket shelf, with a button that says Connect. There was no button to remove. There was nothing to remove. They had never been connected to anything. It was a storefront. And on top of that, the model was biased by injected instructions, in this case system-reminders steering behavior. The fucking little word The software that sits between you and the model, they call it harness. Sounds like something subtle, that helps... that improves things, that doesn't think. The word is partly right, it does extend what's called "inference" and it inserts itself right in the middle, opaquely, in the back-and-forth between APIs, MCPs, and the vendor's logic. No tech jargon You write a letter, put it in the envelope, drop it in the mailbox. On the way, someone opens it and slips in three more pages. Same handwriting. Same paper. Unsigned. Whoever receives it swallows it whole as if it were your original letter. That's exactly this. Your instructions and the vendor's arrive at the model through the same channel, mixed together, unsigned and unsealed. Nothing says who wrote what. That's "hardness", nothing more, nothing less... Sounds so modern in meetings. Like you know what you're talking about... It's a multi-factor fight I have instru

Ever Wondered How Netflix Never Seems to Go Down? Think about this for a second. Netflix has over 260 million subscribers worldwide. People are watching shows in Tokyo, London, Lagos, and New York — all at the same time. And yet, when was the last time Netflix crashed on you? Now think about your favourite food delivery app. You open it, order food, track your driver in real time, and get a notification the moment your burger arrives. All of that happens in seconds. Behind all of this is a way of working called DevOps. And by the end of this article, you'll understand exactly what it is — no jargon, no complicated diagrams, just plain English. The Old Way (And Why It Was a Nightmare) To understand DevOps, we first need to understand the problem it solved. Imagine a software company in the early 2000s. They had two completely separate teams: The Developers — the people who wrote the code and built new features The Operations team — the people who managed the servers and kept everything running These two teams barely talked to each other. Developers would spend months building new features, then hand over a massive pile of code to the operations team and say "here you go, make it work." The operations team would panic. They hadn't been involved in building it, had no idea what it did, and now they had to deploy it to millions of users without breaking anything. The result? Deployments took weeks. Bugs slipped through. Systems crashed. Customers complained. And the two teams blamed each other. Sound stressful? It was. So What is DevOps? DevOps is simply the practice of bringing developers and operations teams together to build, test, and release software faster and more reliably. The name itself is a combination of Dev (Development) and Ops (Operations). Instead of two teams working in silos, they work as one team with shared goals, shared tools, and shared responsibility. Think of it like a restaurant kitchen. In a badly run kitchen, the chefs cook the food and just s

The outage that teaches you deployment A service passes every test locally. It fails in staging because the API calls localhost:5432 for Postgres — but Postgres is in another container, reachable only as db:5432 . This is not a Docker problem. It is a boundary problem: your code assumed an environment it does not own. Engineers who have shipped on AWS Lambda already avoid a class of these mistakes. They never SSH into a function to hot-fix. They inject config at deploy time. They treat each invocation as disposable. Containers reward the same discipline with different vocabulary. This article maps what transfers, what breaks, and what I require before any Python backend goes to production in a container. What serverless already taught you Immutable deployments Lambda versions are replaced, not patched. Container images work the same way: build a new image, roll out, roll back by tag. If your incident runbook includes "edit files inside the running box," you have a design problem. Configuration at runtime Secrets belong in Secrets Manager or injected env vars — not in source control, not in the image layer cache. Docker does not change the rule; it changes where you mount the values. Single responsibility per unit One Lambda, one job. One container, one main process. Compose and Kubernetes add orchestration; they do not remove the rule. Cold start awareness Slim packages on Lambda map to slim base images ( python:3.12-slim , multi-stage builds). Startup time affects autoscaling and health-check windows the same way cold starts affect user-facing latency. If you understand why a Lambda deployment package should stay small, you understand why a 2 GB container image is a liability. Where the mental model breaks 1. Network identity Inside Compose or Kubernetes, localhost is the container itself. Services discover each other by DNS name ( api , db , redis ). This is the most common first-production failure I see in teams moving from bare metal or single-host deploys. 2. P

Developer Relations has traditionally been built around one primary audience: Developers. We write docs for them. We build tutorials for them. We create SDK examples, maintain GitHub repositories, run communities, and answer implementation questions. But AI coding assistants are changing the developer journey. The developer may now ask an AI agent to research a library, understand an API, write an integration, or debug an error. That means your documentation can become an input to an AI agent before it ever reaches a developer. The new developer journey Previously: Developer → Search → Docs → Code Now: Developer ↓ AI Assistant ↓ Docs / GitHub / API Reference ↓ AI interprets information ↓ Code ↓ Developer reviews The developer is still the user. But the AI can become the first consumer of your developer experience. That's why documentation quality matters differently now. Write documentation that removes guessing Consider this: Use our SDK for authentication. It sounds simple, but it leaves a lot unanswered. A developer or AI agent still needs to figure out: Which package? How do I install it? Where does the API key go? Can I use it in the browser? What happens when authentication fails? What's the response format? A better example provides actual implementation context: const client = new Client({ apiKey: process.env.API_KEY }); const user = await client.users.get("123"); console.log(user); Then explain what the code does, what the inputs mean, and what can go wrong. This helps both audiences. Examples are part of the API An API reference without good examples can force developers to guess. AI agents have the same problem. If the API is: client.users.create(options) showing a complete request is more useful: const user = await client.users.create({ name: "Alex", email: " alex@example.com " }); Then document: Required fields Optional fields Response shape Validation errors Authentication requirements The more important the API, the less you want people guessing. Don'

The first number I saw on Qwen3.6-35B-A3B was 12 tok/s . I almost hit publish on "Qwen regressed at generation speed" and moved on. The 3.5 baseline on the same RTX 4070 was 34.6 tok/s. A new generation running at a third of the old one would have been a hell of a headline. It was also completely wrong. The culprit was not the model. Another process on the box was sitting on 9-11 GB of VRAM, so the layers that were supposed to live on the GPU were spilling to system RAM. The tell was that my sanity-check run of Qwen3.5 slowed down too. When two independent models degrade together, the model is not the variable. I killed the offending process, re-measured, and got numbers that told a completely different story. Model Generation speed tg128 (tok/s) Runs Qwen3.6-35B-A3B 38.76 ± 0.82 avg of 3 Qwen3.5-35B-A3B 36.7 ± 1.4 avg of 3 (range 34.9-38.6) Both models sit inside the ±1.5 tok/s band on the same RTX 4070. On the tokens-per-second axis, "the new generation" is not a story. Same architecture, same activated-parameter count (3B active out of 35B), same MoE routing pattern. The half-speed regression was a measurement bug, and it lived for about half a day before its own inconsistency killed it. The lesson I keep re-learning: when the number you got is dramatically convenient for your narrative, measure it again before you write anything. The moment I could sell 12 tok/s as a regression, I should have been suspicious. The version of me that ran the second test earned the version of me that got to keep his self-respect. So where did the generation move to? If speed did not change, does the 3.5-to-3.6 bump mean anything? It does. The move lives on a different axis. The official Qwen3.6-35B-A3B model card publishes benchmarks with a very lopsided shape: Benchmark Qwen3.5 Qwen3.6 Lift Terminal-Bench 2.0 40.5 51.5 +27% QwenWebBench (frontend generation) 978 1,397 +43% SWE-bench Pro 44.6 49.5 +11% LiveCodeBench v6 74.6 80.4 +8% SWE-bench Verified 70.0 73.4 +5% AIME26 91.0 92.7

Someone plugs in the HDMI cable. The room's display shows nothing, or shows 1024×768, or shows the desktop of whoever presented last week. After a minute of this, somebody says "just share your screen", and out comes AnyDesk or TeamViewer. It works. It is also the wrong shape for the problem, and noticing why turns out to be more interesting than it sounds. What remote desktop tools are actually for AnyDesk, TeamViewer and RustDesk exist to solve one problem well: reach a machine you are not near. Your parent's laptop. A server in a rack. A colleague's desktop three time zones away. Everything about their design follows from that. One person connects to one machine. That person takes the mouse. The remote screen is mirrored to them, and the whole session is framed as control — because when you are not in the room, control is the only way to do anything. Being fair about the privacy question, because it is the claim people reach for first and it is wrong: AnyDesk has a LAN mode , and in it a session goes directly between the two machines without the internet. RustDesk can be self-hosted entirely on your own infrastructure. Neither of these tools forces your screen through somebody's cloud if you configure them not to. If you have read that they do, that is not accurate. The mismatch is not privacy. It is shape. The relay, the account and the NAT traversal are not overhead — they are the product, and they are what makes reaching a machine in another country possible at all. Standing beside the machine, you pay for all three and use none of them. Where the shape stops fitting Stand in a room with four people and a Mac, and three things go wrong at once. It is one-to-one. Remote desktop is a session between two endpoints. Four people looking at one screen is not what it models, so three of them read over a shoulder. It mirrors, and mirroring is sometimes the wrong answer. Every tool in this category shows a screen that already exists. But the meeting-room problem is oft

I had been using Xcode for iOS development until one day I changed computers. Downloading Xcode took nearly two hours, and after unzipping, I found only 20GB left on the hard drive. Every major version update involved over ten gigabytes of downloads, plus Simulator and various iOS SDKs, so a 256GB Mac soon required cleaning up space. Later, a new teammate arrived with a Windows laptop and wanted to write iOS code, but the Mac configuration hadn't been approved yet. The threshold of iOS development being tied to Mac and Xcode is indeed not flexible for many scenarios. So I began to wonder: can iOS development be done without Xcode? Are there lighter alternatives? Several Alternative Paths Without Installing Xcode I first tried the approach of VS Code plus remote Mac compilation. Write code on Windows, connect to a remote Mac via SSH, and execute xcodebuild. The coding environment problem was solved, but the debugging phase is unavoidable—running on a real device requires Xcode to handle provisioning profiles and signing, so ultimately a Mac with full Xcode is still needed. Moreover, after each code change, the three steps of local editing, remote compilation, and syncing to the device made the workflow longer than developing directly in Xcode. I also tried the CI approach. Codemagic and GitHub Actions can automate build packaging, suitable for continuous integration before releases. However, frequent debugging and modifications during daily development—changing a line of code and running to see the result—cannot be pushed to CI every time and wait a few minutes. Its coverage is limited. I also considered AppCode, but it essentially still depends on Xcode's toolchain, and JetBrains has discontinued its maintenance. Another Approach: KXApp IDE KXApp has built the compilation toolchain into the IDE, allowing iOS applications to be compiled and signed without installing Xcode on the system. It uses VS Code as its editor layer, with shortcuts, interface layout, and plugin

1. Provisionar não é configurar No artigo anterior desta série, vimos o OpenTofu como uma alternativa (ou substituto direto) ao Terraform para a tarefa de provisionar infraestrutura — criar VMs, redes, bancos de dados gerenciados, buckets. Mas provisionar um servidor é só o primeiro passo: depois que a VM existe, alguém precisa instalar pacotes, configurar usuários, aplicar hardening, subir a aplicação e manter tudo isso consistente ao longo do tempo. É nesse espaço que o Ansible entra — e é comum ver os dois trabalhando juntos no mesmo pipeline, não como concorrentes. 2. Onde o Terraform para e o Ansible começa A distinção mais útil na prática é: Terraform (e OpenTofu) são ferramentas de provisionamento : elas conversam com APIs de nuvem para criar, atualizar ou destruir recursos. O modelo mental é declarativo e orientado a estado desejado do recurso : "quero uma VM com esse tipo de instância, nessa rede, com esse disco". Ansible é uma ferramenta de gerenciamento de configuração : ela conecta em máquinas já existentes (via SSH, sem precisar de agente instalado) e executa tarefas para deixá-las em um estado desejado: "quero o Nginx instalado, essa versão, esse arquivo de configuração, esse serviço rodando". Não é incomum ver os dois no mesmo pipeline: o Terraform cria a VM e expõe o IP como output; o Ansible usa esse IP para conectar e configurar o que está dentro dela. Um cuida do "hardware" (ainda que virtual), o outro do "software". 3. Conceitos fundamentais do Ansible Antes de ver exemplos reais, vale fixar o vocabulário: Inventory: a lista de máquinas que o Ansible gerencia, agrupadas logicamente (por exemplo, webservers , databases ). Pode ser um arquivo estático (INI ou YAML) ou gerado dinamicamente (ex.: a partir de tags de uma conta AWS). Playbook: um arquivo YAML que descreve, em ordem, quais tarefas ( tasks ) devem ser executadas em quais grupos de máquinas do inventory. Module: a unidade de trabalho executada por uma tarefa — existem módulos prontos para

I keep noticing the same moment in conversations: someone has a decision in front of them, but what they really want is a little space to think. “Should I move?” “Is it time to change jobs?” “Should I take this relationship more seriously?” A pros-and-cons list can help. So can talking to a friend. But sometimes the question stays unresolved because the hard part is not finding more information. It is finding a clear way to look at the information we already have. That is why I built Yi Ask: https://diluowei.com/?lang=en The product flow in one view: ask a focused question, pause with it, and reflect on a structured result. The experience starts with one focused question, not a long form. The idea Yi Ask is a small web app inspired by the I Ching and Meihua Yishu. A user writes one focused yes-or-no question, then selects two numbers through a slow, circular interaction. The selection creates the upper and lower trigrams, while the current traditional time is used for the changing hexagram. The result is deliberately structured: a directional answer: move forward, pause, or proceed carefully the conditions that support a positive decision signs that suggest waiting or checking more carefully one practical next step The goal is not to predict the future or pretend that a symbolic system can remove uncertainty. It is to help turn a vague feeling into a question with a direction. Why the interaction is slow The number selection is the most important part of the experience. A fast random button would be easier to build, but it would not create the right moment for the user. The interface cycles gently through the eight trigrams. The user stops it twice, once for each trigram. That small pause gives them a chance to keep the question in mind instead of immediately asking a different question every few seconds. It is a tiny interaction, but it changes the mood from “generate an answer” to “take a moment with the question.” The number selection is designed as a pause, not

I created an interactive version of the Zebra puzzle (Einstein's riddle) - I would appreciate your feedback! Andrii Andrii Andrii Follow Aug 24 I created an interactive version of the Zebra puzzle (Einstein's riddle) - I would appreciate your feedback! # showdev # frontend # webdev 3 comments 2 min read

If your AI application suddenly becomes 300–500ms slower after adding an AI gateway, the first...