标签：#AI

AI can generate a test script before you finish your coffee. That sounds like the hard part of test automation has finally been solved. In practice, most teams were never blocked by the first script. They were blocked by everything that came after it: maintenance, flaky runs, slow feedback, weak adoption, unclear ownership, browser differences, and the uncomfortable question of whether the suite is saving more time than it consumes. That is the theme I keep coming back to when I look at test automation in 2026. Creating tests is getting easier. Building a testing system that people trust is still difficult. Here is a practical map of the problems teams are dealing with now, along with deeper guides for each one. Start with the outcome, not the framework A surprising number of automation projects begin with a tool debate. Should we use Selenium? Playwright? Cypress? A no-code platform? An AI agent? Those questions matter, but they come too early. Before choosing a framework, it helps to agree on what test automation actually is , what risks you are trying to reduce, and which feedback needs to arrive faster. For a team starting from scratch, the most useful approach is usually smaller than expected. Pick a business-critical flow, automate it, run it consistently, and learn from the maintenance burden before expanding. This guide to getting started with automated testing explains that process without pretending every manual test should immediately become code. It is also important to distinguish individual checks from genuine end-to-end testing . A test that confirms a button is visible can be useful, but it does not tell you whether a customer can sign up, receive an email, complete a payment, and see the correct result in another system. Teams naturally ask for the fastest way to automate tests . The honest answer is that speed is not just the time needed to create version one. The fastest approach over six months is the one your team can understand, run, repair, an

TL;DR: We launched Tarotas, a tarot reading app, in five languages (Czech, Slovak, Polish, English, German) on a single domain. Each market behaved completely differently. Here is what the data showed us about multi-locale growth. When we started building Tarotas at Inithouse, the plan seemed straightforward: one product, five languages, one domain. Czech as the base, then Slovak, Polish, English, and German. Same cards, same readings, same UI. Just translated. What we did not expect: each locale acts like a separate product. The setup Tarotas is a tarot card app where you draw a card and read a calm, generic interpretation. No fortune telling, no sign-ups, no paywall. 78 cards across five languages, all on tarotas.com with language detection. We built it in Lovable and deployed it in under two weeks. The multi-language part took another week: content generation for 78 cards times 5 languages, plus locale-specific meta tags and URL structures. What the data told us The Czech and Slovak markets responded first. That was expected: our studio is based in Prague, our existing portfolio (products like zivafotka.cz and magicalsong.com ) already had traction in CZ/SK. But the interesting part was the divergence. CZ/SK users stayed longer. Session duration in Czech and Slovak was noticeably higher than in other locales. Users explored multiple cards, came back for second readings. The "reflection" positioning landed well in these markets, likely because tarot has a quiet cultural niche in Central Europe: not mainstream, but not fringe either. Polish users bounced faster but shared more. The PL locale had higher bounce rates but showed a different signal: social referrals. Polish users who did engage were more likely to share readings. The tarot community in Poland leans more social: Facebook groups, Instagram stories, TikTok readings. Our product caught some of that energy. German users barely showed up. DE was our weakest locale by far. German-language search demand for ta

In Mexico, WhatsApp isn't a channel — it's the channel. It's where customers ask for prices, book appointments, and decide whether to buy from you or from the competitor who answered faster. And that last part is the problem: most small and medium businesses lose customers simply because nobody replied in time — after hours, during a rush, or while the owner was busy doing the actual work. At Proxxa , the AI automation agency I run in Mexico City, this is the single most common pain we solve. So I want to walk through how I built a production-grade WhatsApp AI assistant that answers, qualifies, and books 24/7 — using Claude and n8n, with no third-party chatbot platform in the middle. Why the WhatsApp Cloud API directly (no BSP) A lot of guides will tell you that you need a BSP (Business Solution Provider) to use the WhatsApp Business API. You don't. Meta's Cloud API is hosted by Meta itself and you can build on it directly. Skipping the BSP means no per-seat middleman tax, full control over the logic, and the client owns their own number and data. The stack n8n (self-hosted on a small VPS via Docker) as the orchestration layer. Claude (Haiku) as the intelligence layer — fast and cheap enough to answer every message. Postgres for conversation memory, a knowledge base, and a lightweight CRM. WhatsApp Cloud API for the messaging. Gemini for transcribing voice notes. The pattern that made it powerful: meta-blocks Instead of bolting on a separate "agent framework," I let Claude emit small structured blocks inside its answer, which a parsing node extracts and strips before sending — to schedule an appointment, escalate to a human, capture a lead, or generate a payment link. The user only ever sees clean text; the system reacts to the blocks. This kept the whole thing debuggable and predictable. With that pattern, the assistant handles eleven capabilities: natural-language conversation, per-customer memory, Google Calendar booking, vision (it reads a photo a customer sends

Oracle is spending billions on data center infrastructure to support AI.

Menlo has created a solid rep for itself as an AI investor, all based on one gutsy $750 million move in 2024.

Algae blooms, peeling paint, and a host of fixes from hydrogen peroxide to nanobubblers have made it hard to diagnose what's wrong with the Reflecting Pool, let alone how to clean up the mess.

Qdrant is an open-source vector database for AI applications, optimised for similarity search over high-dimensional embeddings, with a REST/gRPC API, payload filtering, and a built-in dashboard. This guide deploys Qdrant using Docker Compose with Traefik handling automatic HTTPS, API-key authentication, and a sample collection that runs a similarity search. By the end, you'll have Qdrant serving vector search securely at your domain. Set Up the Directory Structure 1. Create the project directory: $ mkdir -p ~/qdrant/data $ cd ~/qdrant 2. Generate a strong API key: $ openssl rand -hex 32 Save the value for the .env file. 3. Create the environment file: $ nano .env DOMAIN = qdrant.example.com LETSENCRYPT_EMAIL = admin@example.com QDRANT_API_KEY = PASTE_GENERATED_KEY_HERE Deploy with Docker Compose 1. Create the Compose manifest: $ nano docker-compose.yaml services : traefik : image : traefik:v3.6 container_name : traefik command : - " --providers.docker=true" - " --providers.docker.exposedbydefault=false" - " --api.dashboard=false" - " --entrypoints.web.address=:80" - " --entrypoints.websecure.address=:443" - " --entrypoints.web.http.redirections.entrypoint.to=websecure" - " --entrypoints.web.http.redirections.entrypoint.scheme=https" - " --certificatesresolvers.letsencrypt.acme.httpchallenge=true" - " --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web" - " --certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}" - " --certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json" ports : - " 80:80" - " 443:443" volumes : - " ./letsencrypt:/letsencrypt" - " /var/run/docker.sock:/var/run/docker.sock:ro" restart : unless-stopped qdrant : image : qdrant/qdrant:v1.17.1 container_name : qdrant expose : - " 6333" volumes : - " ./data:/qdrant/storage" environment : QDRANT__SERVICE__API_KEY : " ${QDRANT_API_KEY}" labels : - " traefik.enable=true" - " traefik.http.routers.qdrant.rule=Host(`${DOMAIN}`)" - " traefik.http.routers.qdrant.entr

MLflow is an open-source platform for managing the machine learning lifecycle — experiment tracking, model registry, and reproducible runs. This guide deploys MLflow using Docker Compose with a PostgreSQL backend, S3-compatible artifact storage, basic-auth, and Traefik handling automatic HTTPS, then logs a sample scikit-learn run. By the end, you'll have MLflow recording experiments at your domain over HTTPS. Prerequisite: An S3-compatible bucket (e.g. Vultr Object Storage) with access key, secret key, region, and endpoint URL. Set Up the Directory Structure 1. Create the project directory: $ mkdir -p ~/mlflow $ cd ~/mlflow 2. Create the environment file: $ nano .env DOMAIN = mlflow.example.com LETSENCRYPT_EMAIL = admin@example.com POSTGRES_USER = mlflow POSTGRES_PASSWORD = StrongDatabasePassword123 MLFLOW_AUTH_CONFIG_PATH = /app/basic_auth.ini MLFLOW_FLASK_SERVER_SECRET_KEY = GENERATED_SECRET_KEY S3_BUCKET = mlflow-artifacts S3_ACCESS_KEY = YOUR_ACCESS_KEY S3_SECRET_KEY = YOUR_SECRET_KEY S3_REGION = YOUR_REGION S3_ENDPOINT = https://YOUR_OBJECT_STORAGE_ENDPOINT 3. Create the basic-auth configuration: $ nano basic_auth.ini [mlflow] default_permission = READ database_uri = sqlite:///basic_auth.db admin_username = admin admin_password = ADMIN_PASSWORD authorization_function = mlflow.server.auth:authenticate_request_basic_auth 4. Create a Dockerfile that adds the auth-server extras and Postgres/S3 clients to the official image: $ nano Dockerfile FROM ghcr.io/mlflow/mlflow:v3.10.1 RUN pip install --no-cache-dir psycopg2-binary boto3 'mlflow[auth]' Deploy with Docker Compose 1. Create the Compose manifest: $ nano docker-compose.yml services : traefik : image : traefik:v3.6 container_name : traefik command : - " --providers.docker=true" - " --providers.docker.exposedbydefault=false" - " --entrypoints.web.address=:80" - " --entrypoints.websecure.address=:443" - " --entrypoints.web.http.redirections.entrypoint.to=websecure" - " --entrypoints.web.http.redirections.entrypoint

LocalAI is an open-source platform for running Large Language Models locally with an OpenAI-compatible API, so you can swap it in behind existing OpenAI client code without paying per-token or sending data off-server. This guide deploys LocalAI using Docker Compose with Traefik handling automatic HTTPS, persistent model and cache directories, and a working chat-completion test. By the end, you'll have LocalAI serving an OpenAI-compatible API securely at your domain. Set Up the Directory Structure 1. Create the project directories: $ mkdir -p ~/localai/ { models,cache } $ cd ~/localai models/ holds downloaded model files; cache/ persists between restarts. 2. Create the environment file: $ nano .env DOMAIN = localai.example.com LETSENCRYPT_EMAIL = admin@example.com Deploy with Docker Compose 1. Add your user to the Docker group: $ sudo usermod -aG docker $USER $ newgrp docker 2. Create the Compose manifest: $ nano docker-compose.yaml services : traefik : image : traefik:v3.6 container_name : traefik restart : unless-stopped environment : DOCKER_API_VERSION : " 1.44" command : - " --providers.docker=true" - " --providers.docker.exposedbydefault=false" - " --entrypoints.web.address=:80" - " --entrypoints.websecure.address=:443" - " --entrypoints.web.http.redirections.entrypoint.to=websecure" - " --entrypoints.web.http.redirections.entrypoint.scheme=https" - " --certificatesresolvers.le.acme.httpchallenge=true" - " --certificatesresolvers.le.acme.httpchallenge.entrypoint=web" - " --certificatesresolvers.le.acme.email=${LETSENCRYPT_EMAIL}" - " --certificatesresolvers.le.acme.storage=/letsencrypt/acme.json" ports : - " 80:80" - " 443:443" volumes : - /var/run/docker.sock:/var/run/docker.sock:ro - ./letsencrypt:/letsencrypt localai : image : localai/localai:latest-aio-cpu container_name : localai restart : unless-stopped volumes : - ./models:/models:cached - ./cache:/cache:cached healthcheck : test : [ " CMD" , " curl" , " -f" , " http://localhost:8080/readyz" ] interval :

LibreChat is an open-source, ChatGPT-style web UI that supports OpenAI, Anthropic, Azure OpenAI, Gemini, OpenRouter, local OpenAI-compatible endpoints, and more — with MongoDB-backed conversation history and Meilisearch-powered search. This guide deploys LibreChat using its official Compose manifest plus a Traefik override for automatic HTTPS. By the end, you'll have LibreChat running with a registration page and multi-provider chat at your domain over HTTPS. Clone LibreChat and Prepare the Environment 1. Clone the LibreChat repository and check out a stable tag: $ git clone https://github.com/danny-avila/LibreChat.git $ cd LibreChat $ git checkout tags/v0.8.3 2. Find the Meilisearch data directory name pinned by this release: $ grep -o 'meili_data_v[0-9.]*' docker-compose.yml | head -1 3. Create the required data directories (replace meili_data_v1.35.1 if the previous command printed a different name): $ mkdir -p data-node images logs meili_data_v1.35.1 uploads $ sudo chown -R 1000:1000 meili_data_v1.35.1 4. Copy the env template and uncomment the UID/GID lines: $ cp .env.example .env $ nano .env UID = 1000 GID = 1000 Override the Compose Stack with Traefik 1. Create a Compose override that adds Traefik and wires the API to it: $ nano docker-compose.override.yml services : api : labels : - " traefik.enable=true" - " traefik.http.routers.librechat.rule=Host(`librechat.example.com`)" - " traefik.http.routers.librechat.entrypoints=websecure" - " traefik.http.routers.librechat.tls.certresolver=leresolver" - " traefik.http.services.librechat.loadbalancer.server.port=3080" volumes : - ./librechat.yaml:/app/librechat.yaml traefik : image : traefik:v3.6.10 ports : - " 80:80" - " 443:443" volumes : - " /var/run/docker.sock:/var/run/docker.sock:ro" - " ./letsencrypt:/letsencrypt" command : - " --providers.docker=true" - " --providers.docker.exposedbydefault=false" - " --entrypoints.web.address=:80" - " --entrypoints.websecure.address=:443" - " --entrypoints.web.http.redirect

There's a moment in every ambitious AI engineering project where you convince yourself that more agents means more power. I hit that moment early in building my Python orchestration framework — and I spent several painful weeks learning exactly why that intuition is wrong. The seductive pitch: decompose complex tasks into specialized sub-agents, run them in parallel, let them coordinate. What actually happened was a reliability nightmare that taught me more about agentic architecture than any framework documentation ever could. The Problem I Actually Built My Python orchestration system was designed to automate complex, multi-step workflows — the kind that require planning, research, code generation, and validation to happen in a coherent sequence. Early on, I structured it as a web of parallel agents: a planner, several workers, a validator, and a synthesizer, all exchanging structured messages. On paper it was elegant. In practice, it had three failure modes I couldn't engineer away: Context drift. Each agent only saw the slice of information it was handed. The worker writing one module couldn't see what the worker writing another module had decided. By the time the synthesizer tried to combine outputs, I had conflicting assumptions baked into the results — variable names that clashed, patterns that contradicted each other, interfaces that didn't align. Cascading partial failures. When one agent produced ambiguous output, every downstream agent amplified the ambiguity. A planner that returned a slightly underspecified task description produced workers that each interpreted it differently. Nothing failed loudly. Everything just drifted, quietly, until the final output was incoherent. Debugging opacity. When something went wrong in a parallel multi-agent system, tracing the failure was miserable. Was it the planner? One of the workers? The message-passing layer? I'd rebuilt the worst parts of distributed systems debugging inside a single Python process. The Architec

Anthropic’s new Claude Tag brings an always-on AI teammate to Slack. But beyond productivity, the feature is a strategic play to capture organizational context, institutional knowledge, and enterprise workflows.

GPT-5 Pro helped solve a 3-year-old immunology mystery, offering insights into T cell behavior. The breakthrough could support cancer and autoimmune research.

Hello and welcome to Regulator, the newsletter for Verge subscribers chronicling the misadventures of their favorite tech overlords and Washington swamp creatures. ("Favorite" is, of course, subjective.) Not a subscriber yet? Sign up here, especially if you want the hot scoop on quality Amazon Prime Day deals recommended by the wonderful humans of The Verge's […]

Explore how my day as a senior leader looks now that I use 40 automations to help, and learn more about some of my favorites. The post I automated my job (and it made me a better leader) appeared first on The GitHub Blog .

Beyond the Prototype: Why Teams Need More Than Vibe Coding Over the last year, AI coding tools such as Lovable, Bolt.new, v0, Base44, and others have fundamentally changed how software gets created. A single founder or developer can now go from a rough idea to a working prototype in hours rather than weeks. That kind of acceleration is genuinely exciting, and it has opened software creation to far more people. That democratization is a good thing. Rapid experimentation, faster feedback loops, and lower barriers to entry are changing how products get started. Many successful companies and ideas will emerge because these tools made building more accessible. As I've followed the conversations happening around these tools—through reviews, articles, community discussions, and the experiences being shared by founders and engineering leaders—I've noticed an interesting pattern. The challenge is no longer getting to the first version. The challenge begins after. The Prototype Was Never the Finish Line The prototype works. Stakeholders become excited. Customers show interest. Momentum builds. Then a different set of questions starts to emerge. How do we align everyone on what we're building? How do we evolve an existing application instead of starting over? How do we maintain quality as complexity increases? How do multiple people collaborate without losing context? How do we know whether we're delivering the outcomes we intended? And how do we continuously improve without creating chaos? These aren't failures of AI coding tools. They're simply different problems. Many of today's AI builders are optimized for individual acceleration and rapid exploration. But once a promising idea becomes a product that teams must own, maintain, and evolve together, different requirements naturally emerge. What works for one person experimenting is not always enough for a group of people building something intended to last. Building Software Is More Than Generating Code Software development

Your prompts are fine. Your AI output is still garbage. You write carefully. You're specific. You ask for the format, the tone, the length. Hit enter. The AI responds with something that sounds like it was written by a committee of lawyers having a really bad day. Here's what you don't realize: You're not telling the AI to do something. You're describing the problem, and the AI is solving for the statistical average. The fix isn't more detailed instructions. It's three examples. That's it. Three. Not ten, not one, three. This post is the complete guide to few-shot prompting — the single highest-leverage move in prompt engineering. By the end, you'll have a template you can copy into any AI and watch your output quality jump 5x. Prefer watching? Here's the 3-minute version Otherwise, read on — everything's below. Why Instructions Fail (And Examples Work) When you tell an AI to "be funny," it's working off a fuzzy statistical average of everything labeled "funny" in its training data. When you show an AI what you think is funny, you're giving it a precise pattern to match. Here's the difference: ❌ Instruction: "Write a funny one-sentence movie summary" Result: A lukewarm joke that lands in the middle of the comedy bell curve. ✅ Pattern: Funny summary of The Lion King: Cub loses dad. Cub becomes king. Funny summary of Finding Nemo: Dad fish swims very far for his son. Funny summary of Titanic: [AI fills this in] Result: Boy meets girl. Boat meets iceberg. Oops. Same AI. Different universe. The only thing that changed: you showed it the pattern instead of describing it. The Science (Why This Isn't Magic) Language models predict the next token by pattern matching. They've seen millions of prompt-response pairs and learned: "When a prompt looks like this , the output usually looks like that ." One example could be a fluke. Two examples might be a coincidence. Three examples are clearly a pattern. The AI recognizes the pattern and completes it. This is exactly how humans l

This post is my submission for DEV Education Track: Build Apps with Google AI Studio . What I Built I set out to build the same app as the one mentioned in the Tutorial. Please create an app that generates a unique new Magic the Gathering card, using Imagen for the visuals, and Gemini to create the text descriptions and stats for the card. Apply the "Sophisticated Dark" design theme to the app. Spammed Fix Errors Non-Stop After this other than the Manual Entry option. Demo My Experience You can't trust Gemini Flash even for the Task provided in the Tutorial Standalone at least and well I spammed Fix Errors and they removed the Auto-Fixing of Errors because of idk an infinite loop or something but well the Error Fixing Experience was quite Meh considering I haven't delved into Vue and React in that level yet so I just 'Vibe Coded' and I found out with this experience that Vibe-Coding is UnCool. I think I would do the other course after properly understanding concepts behind it unlike the way I jumped in this One.

I've been working as Software Developer mainly focussed on Java and builts many application using Eclipse RCP framework or VS Code Application. Almost all the time I had to deal with multiple large files (either read/generate/validate) them which seemed very difficult and some of them almost impossible as most of them would be dependant on each other and would be referencing each other (just like how java files work together). Now assume client1 requires the same content in multiple Json files and client2 needs it in xml files. We couldn't go on writing a different application or go on adding if conditions and blah blah blah !!!! Wouldn't it be easier if as soon as I execute the application it generates the content in whatever format I choose and also taking care of dependencies/ references (like adding import statements). Additionally integrate with features of IDE and provide proposals, perform validations on the fly. Rela World Examples : Try googling Arxml once (Trust me I've dealing with these files for almost 7 years and it's always a nightmare to debug these) Solution: Xtext framework In this tutorial, I will show you how to use Eclipse Xtext and Xtend to build a simple, readable DSL that automatically generates Java boilerplate for you. Fair Warning: There will be no running executions screenshots or anything. You are gonna have to run it yourself and check the results and of course questions are always welcome in the comments section. But if for some reason you are unable to replicate this then let me know I'll try to explain further. I believe the best way to learn is by doing it yourself. The Goal: What are we building? Instead of writing 100 lines of Java with private fields, getters, and setters, we want our developers to write 5 lines of code in our own custom language (basically you can create your own programming language with your own custom syntax), like this: entity User { var name : String var age : Integer } When this file (assume file extension

HaloBraid aims to help salons speed up braiding with its first device, slated to launch later this year, that acts as a braiding assistant for professional stylists.