标签：#Productivity

Let's be honest: standard AI chatbots are getting a bit boring. You ask them a question, they write back a beautiful paragraph of text, and then... nothing. They don’t actually do anything for your business. If you want to add a customer to your CRM, update a product on your website, or change something in your database, you still have to do it manually. That is why we decided to build something different. Instead of another chatbot that just talks, we created Gaotus Gaotus! See . It is an "execution AI" layer. This means it doesn't just reply to you—it actually connects to your tools (like WordPress, custom dashboards, or APIs) and does the manual work for you. Think of it like this: No more boring web forms to fill out. You just talk to the system, and it updates the database automatically. It checks the data for mistakes and logs everything securely before making any changes. It saves hours of manual data entry for small businesses. We are currently testing it with real-world scenarios, like automatic customer onboarding and syncing car dealership listings straight to web marketplaces. Since we are launching and improving this system, we would love to hear from other developers and creators: What is the most boring, repetitive task in your daily workflow that you wish an AI could just execute for you? Let’s chat in the comments!

Um relato honesto de alguém que trabalha com design, vive com TDAH e está cansada de dicas genéricas Tem um tipo de artigo sobre organização que eu já sei de cor. É sempre alguma variação de: “faça uma lista, use Pomodoro, durma 8 horas e beba água”. Só que tem um cenário que quase nunca aparece nessas listas: O momento em que você não é neurotípica, está em burnout, tem duas tarefas importantes com o mesmo prazo e nenhuma técnica milagrosa resolve. É sobre isso que eu quero falar aqui. Sumário: O cenário caótico (e bem real) Por que o Pomodoro não funciona pra todo mundo Burnout em quem tem TDAH O dia em que duas tarefas importantes têm o mesmo prazo Estratégia 1: uma prioridade verdadeira por dia Estratégia 2: subtarefas em vez de cronômetro Estratégia 3: time blocking gentil (agenda que não te esmaga) Estratégia 4: reduzir fricção em vez de exigir mais disciplina Estratégia 5: contratos curtos consigo mesma E quando nada disso parece suficiente? Referências O cenário caótico (e bem real) Imagina o seguinte: Projeto A : entrega do pitch da pós, com prazo na sexta. Projeto B: preparar apresentação do roadmap, também para sexta. Você já está cansada, a cabeça rodando, o corpo em modo economia de energia. Aí você joga no Google “como se organizar” e recebe de volta: “Use a técnica Pomodoro, 25 minutos de foco, 5 de pausa.” E você pensa: “Amiga, eu mal estou levantando da cama. Você quer que eu vire um cronômetro humano?” A real é que muita técnica de produtividade tradicional foi pensada para cérebros neurotípicos. Quando a gente vive com TDAH, burnout ou os dois juntos, essa lógica simplesmente não encaixa tão bem. Por que o Pomodoro não funciona pra todo mundo Pomodoro é ótimo… para algumas pessoas. Mas tem motivos bem específicos para ser um caos para muitos de nós. Por exemplo: A pausa obrigatória, interrompe justo quando o foco finalmente chegou. A sensação do timer contando, aumenta a ansiedade em vez de ajudar. Cada “reinício de ciclo” vira mais uma micro deci

A solo developer with a $200/month budget can now access the same AI coding power that cost enterprises $50,000/month just two years ago. The secret isn't one tool — it's knowing how to mix and match three different access models to get frontier output at budget prices. I've been running this exact stack for months. Here's the breakdown. The Three Ways to Access AI Coding Models Before we talk strategy, understand your three options. Each has a wildly different cost profile. Option 1: Self-Hosted Open Models With models like GLM-5.2 hitting near-Claude Opus quality under MIT license, self-hosting is finally viable. The math is straightforward. Hardware cost: A dedicated GPU server (RTX 4090 or A100) runs $300–$800/month. An H100 rental starts at $1.99/hour on platforms like RunPod. Break-even point: According to cost analysis from multiple providers, self-hosting becomes cheaper than APIs at roughly 5–10 million tokens per month for premium-tier models [1]. Below that volume, you're paying for idle hardware. The catch: You need DevOps skills. Model deployment, quantization, monitoring, failover — it's real infrastructure work. If you save $500 on compute but burn out managing GPUs on weekends, you lost money. Best for: Teams with predictable, high-volume workloads and existing DevOps capability. Think 100M+ tokens/month where savings hit $5M+ annually [2]. Option 2: Pay-Per-Token APIs The default starting point. You pay exactly for what you use. Current pricing (early 2026, per 1M tokens): GPT-4o: $2.50 input / $10.00 output Claude 3.5 Sonnet: $3.00 input / $15.00 output Gemini 1.5 Pro: $1.25 input / $5.00 output DeepSeek V3: $0.27 blended (yes, really) Together AI (Llama 70B): $0.88 blended [1] The pricing floor crashed when DeepSeek V3 arrived at $0.27/M tokens with GPT-4-class quality. Open-source models routed through providers like Together AI or Cerebras ($6–12/M tokens at 969 tok/s) give you more options than ever. The trap: Pricing scales linearly forever. A

Designing a modern Production Scheduling Software for film production is a fascinating challenge. Film scheduling is essentially solving a massive, multi-dimensional puzzle where the pieces are constantly changing, and the rules are dictated by art, logistics, weather, and strict labor union contracts. Legacy tools like Movie Magic Scheduling have been the industry standard for decades, but they are often clunky, desktop-bound, and lack real-time collaboration. A next-generation film scheduling tool needs to bridge the gap between complex logistical logic and a modern, collaborative user experience. Here is. what a top-tier SaaS Production Scheduling Software should have the following: The Core Engine: Script Breakdown & Ingestion Before you can schedule, you have to break down the script. This process must be frictionless. Universal Script Import: Flawless parsing of Final Draft (.fdx), Celtx, Fountain, and PDF formats. AI-Assisted Auto-Tagging: The software should automatically read a scene and highlight elements (Cast, Stunts, VFX, Special Effects, Props, Vehicles, Animals, Extras). Customizable Breakdown Sheets: Department heads need to see specific data. The software must allow users to create custom categories and color codes for breakdown sheets. Scene Splitting/Merging: The ability to easily split a scene (e.g., Scene 42A, 42B) or merge scenes if the script changes during prep. The Scheduling Interface (The "Stripboard") The visual representation of the schedule is where the 1st Assistant Director (1st AD) and Unit Production Manager (UPM) will spend 90% of their time. Drag-and-Drop Stripboard: A highly responsive, tactile interface where scenes are represented by colored "strips" that can be dragged, dropped, and reordered. Smart Sorting & Filtering: One-click sorting by Day/Night, Int/Ext, Location, Cast Members, or Script Order. The "Honor" System: The ability to group scenes by specific constraints (e.g., "Schedule all scenes with the child actor first,"

Built Vidilearn — an AI-first CLI for extracting YouTube transcripts, subtitles, chapters, articles, and structured metadata locally with zero API keys. Supports MCP servers, AI agents, RAG pipelines, Codex CLI, Gemini CLI & more. GitHub: https://github.com/Alfo-Tech-Lab/vidilearn

Why I Chose GoFr for My Backend Project When starting a new backend project, one of the first decisions I need to make is choosing the right framework. Over the years, I’ve experimented with different backend technologies, each offering its own strengths and trade-offs. For my latest project, however, I decided to try something different: GoFr. At first, I was simply exploring the Go ecosystem and looking for tools that could help me build production-ready services faster. What caught my attention wasn’t just that GoFr was built in Go—it was the philosophy behind it. Instead of forcing developers to spend days configuring infrastructure, wiring dependencies, and setting up observability, GoFr focuses on helping developers get from idea to deployment quickly. In this article, I’ll share the reasons why I chose GoFr for my backend project and what stood out during my experience. The Problem with Starting Backend Projects Every backend project begins with excitement. You have an idea, a feature roadmap, and a vision of what you’re trying to build. Yet before writing meaningful business logic, developers often spend hours or even days configuring: Logging Database connections Metrics Tracing Health checks API routing Environment management Deployment configurations While these tasks are necessary, they rarely contribute directly to solving the actual problem your application is meant to address. As a developer who frequently builds side projects and prototypes, I wanted a framework that reduced this setup overhead while still following good engineering practices. That’s where GoFr entered the picture. What Initially Attracted Me to GoFr The first thing I noticed was how quickly I could get a service running. Instead of navigating through multiple configuration files and third-party packages, GoFr provides many essential backend capabilities out of the box. This means less time deciding which libraries to install and more time focusing on application logic. The framework

Notes from building a memory layer that forgets on purpose. Most "memory-enabled" agents don't remember anything. They re-read. Every turn, the whole conversation gets pasted back into the prompt, and we call that memory because the model can answer questions about earlier turns. It's a good trick. I used it for months. It also falls apart the moment real people start using the thing, and it falls apart in three separate ways. The first is the one everyone notices: it's expensive and noisy. You re-send every prior turn on every request. The single line you actually care about - "I'm allergic to peanuts" - is buried under a thousand lines of small talk, and you pay for all of it, every time. The second is quieter and worse. Transcript-stuffing has no idea what stale means. If someone told your agent "I'm vegetarian" in March and "I eat fish now" in May, you've just handed the model both facts with equal weight. Now it has to guess which one is current. Sometimes it guesses wrong, and there's nothing in the system that even thinks that's a problem. The third one is the reason I stopped treating this as a side quest. When you finally add summarization to control the cost from problem one, the summarizer is free to drop whatever it wants to save tokens. Including the allergy. I spent years around fintech, where the wrong record surviving (or the right one quietly vanishing) is how people get hurt, so this landed hard: forgetting an allergy to save 40 tokens isn't a cost bug. It's a safety bug wearing a cost bug's clothes. So the question I actually wanted to answer wasn't "how do I make my agent remember more." It was: how do I build something where acting on a fact the user already retracted and silently dropping a fact that must survive are impossible by construction, not just unlikely if the prompt is good that day. Everyone has already solved one third of this The encouraging part is that you don't have to invent much. The discouraging part is that every existing sy

Most developers have done this at least once. You get a messy API response. You need to inspect a JWT. You have a webhook payload, a log object, or a config file that is hard to read. So you open a JSON formatter, paste the content, and move on. That habit is convenient. But it also deserves a second look. Not every JSON tool behaves the same way. Some tools process your input entirely in the browser. Some send content to a server. Some store snippets for sharing. Some extensions have permissions that are broader than you expect. The problem is not that every online formatter is unsafe. The problem is that you often do not know what happens after you paste. What you should avoid pasting blindly Before using any random online tool, be careful with: production JWTs API responses containing user data logs from real systems config files webhook payloads database URLs cloud keys internal endpoints tenant IDs error traces from production systems A JSON payload does not need to contain an obvious password to be sensitive. Sometimes the risky part is context: user IDs, internal URLs, tokens, customer data, or system structure. A quick DevTools check You can do a basic check with your browser’s DevTools. Open the JSON tool. Open DevTools. Go to the Network tab. Clear existing requests. Paste a harmless test JSON first. Run format, validate, diff, decode, or whatever action the tool provides. Watch the Network tab. Look for POST, PUT, fetch, XHR, or beacon requests after your input. Inspect request payloads if they exist. Check whether your pasted JSON appears in any request. Do this with harmless test data first. If the tool uploads the test JSON, do not paste production content into it. What to look for A few signs deserve attention: POST requests after you paste or click format request bodies containing your JSON share-link features that save snippets server-side validation APIs analytics events that include pasted content extension background requests that are not clearly

We Built ARK Because Our Customer Support Was Spread Across 4 Apps The Problem A few months ago, our small team was drowning. Not in customers (well, a little) — but in tabs. WhatsApp open in one window. Instagram DMs in another. A live chat widget buried in a third. Email in a fourth. Every time a customer reached out, someone had to figure out: which channel did this come from, has anyone replied already, and what was the context of the last conversation? The result was predictable: slower replies, repeated questions to customers, and a support workflow that didn't scale past a handful of conversations a day. Why Existing Tools Didn't Fit We looked at the usual suspects — Intercom, Zendesk, Front. They're solid products, but they're built for large support teams with big budgets and dedicated admins. We needed something simpler: a single inbox, AI doing the repetitive work, and a setup that doesn't take weeks to configure. What We Built ARK pulls every customer conversation — WhatsApp, Instagram, Messenger, email, live chat — into one inbox. On top of that, AI handles three things: Drafting replies based on conversation history and context Summarizing long threads so anyone on the team can jump in without reading 40 messages Routing conversations to the right person automatically based on topic or channel The goal wasn't to replace human support — it was to remove the busywork so the team can focus on actually helping people. Where We Are Now ARK is live with a 7-day free trial (auto-renews after that). We're still early, and we're shaping the roadmap based on real feedback from teams managing support across multiple channels. If you're dealing with the same multichannel chaos we were, I'd love to hear how you're handling it — and what's still missing from the tools you've tried. 🔗 https://byark.ai/

After posting several articles about the impact of AI on developers and sharing resources to help...

Obsidian prompts beat open-ended reflection every time: median review time across 6 weeks was 14 minutes, fastest was 9, slowest was 22 (and that week genuinely deserved 22). I ran the GTD-adjacent version faithfully for six weeks — 90 minutes, full capture sweep, energy audit, the works. Then less faithfully for two months. Then I stopped entirely and didn't notice for three weeks. That last part is the failure mode nobody writes about. The format wasn't wrong; it was sized for a version of my week that rarely existed. The fix wasn't a better framework. It was shorter, closed questions. My Obsidian template has seven prompts, none of them open-ended: what shipped, what didn't, what I avoided and why, one thing to drop, one thing to protect. One-to-three sentence answer ceiling per prompt, hard stop. Open questions like "how was your week?" generate rumination. Closed questions generate decisions. That distinction is doing almost all the work. The Notion version I ran before this taught me something useful about tool selection too. I built rollups — tasks closed this week, open tasks by project, inbox count, stalled for 7+ days — and they worked exactly as designed. What Notion couldn't do was get out of its own way during actual reflection. Every time I tried to think through what went wrong, I'd end up reorganizing a database instead. Forty minutes later, new linked database, zero review completed. The same flexibility that makes Notion a good data layer makes it a bad "close the loop and move on" environment. Obsidian's plain-file simplicity is the right call for the thinking layer — and completely wrong for the data layer. Neither tool alone is the honest answer. There's also a cautionary note from my automation setup: a Zapier zap that pushed completed tasks into Notion for weekly rollup ran cleanly for two months, then silently broke when my task manager updated their API response format. Modified tasks started logging as completed. My rollup became noise befo

That's the reality of what I've been testing - whether you can actually run a micro SaaS from a phone. Not as a gimmick, but as a real workflow. The key is prompting discipline. When I want a changelog section added to my delivery page, I'm not just asking. I'm structuring the task: queue it up, do QA after each step, create the build, update the OTA link, ping me on Telegram, then move to the next one. If something breaks, take notes and continue - I'll deal with it later. The AI handles the repetitive loop. I handle the decisions. Most of my dev ops now fits in a chat thread. Is this the future of solo building? Maybe. Or maybe it's just a useful edge case for when your laptop is in for repair and you have a deadline. Either way, it's worth knowing what's actually possible.

As developers, we compare files constantly — reviewing pull requests, checking config changes, spotting bugs between versions. But not all diff tools are created equal. Some require installation, some upload your files to remote servers, and some just don't support the formats you need. Here's a rundown of the best free file diff tools available in 2026, so you can pick the right one for your workflow. 1. FileDiffs — Best for Privacy & Format Support If you work with sensitive files or just don't want your data sitting on someone else's server, FileDiffs is the tool you need. What makes it stand out: Supports 60+ file formats — PDF, Word, Excel, code files, JSON, XML, CSV and more Runs entirely in your browser — client-side processing means your files never leave your device 100% private — zero data transfer, zero uploads, zero risk No install, no signup, no hassle — just open and compare It's the go-to tool when you need to compare files quickly without worrying about privacy or compatibility. 2. Meld — Best Desktop Diff Tool Meld is a classic open-source visual diff and merge tool for Linux, Windows, and macOS. It's great for comparing files, directories, and version-controlled projects. Best for: Developers who prefer a desktop app and work heavily with Git. 3. Beyond Compare — Best for Power Users Beyond Compare is a feature-rich diff tool with support for files, folders, FTP, and cloud storage. It's not free (paid after trial) but worth mentioning for its depth of features. Best for: Teams that need advanced folder sync and merge capabilities. 4. Diffchecker — Quick Online Diffs Diffchecker is a simple web-based diff tool for text and code. It's quick and easy but uploads your content to their servers and has limited format support compared to FileDiffs. Best for: Quick one-off text comparisons where privacy isn't a concern. 5. KDiff3 — Best for Three-Way Merges KDiff3 is a free, open-source diff and merge tool that supports three-way comparison. It's a bit dat

TL;DR: Two tools cut Claude Code token usage at two different layers. RTK is a shell proxy that compresses command output before it ever reaches the context window. context-mode is a Claude Code plugin that does heavy tool work in a sandbox and hands back only the answer. They stack cleanly on top of each other, and a single skill installs both. This article explains how each one works and how to wire them in. Two commands into a session, my context window was already a third full, and I hadn't written a line of code yet. A pnpm install had dumped its entire dependency tree, a git log paid out two hundred commits, then a stack trace landed in full. None of that was work I'd asked for - it just sat there in the context window eating tokens on every turn. Most of the token budget goes on that boring output - the installs, the logs, the traces - which piles up and gets re-read on every single turn, never on the clever reasoning you actually wanted. Two tools attack that pile from two directions. Here's how they work, and how to install both in one command. This is the last article in the series, and it builds on the skill pattern from the third. You can pass this article URL straight to Claude Code and follow along. Where the tokens actually go Picture the context window as a desk. Everything Claude needs stays on the desk so it can glance at it: your prompts, its replies and the output of every command it ran. The desk has a size limit, and once something is on it, it gets re-read on every turn until it falls off the edge. Two kinds of clutter land there: Command output that arrives bloated. A dependency install, a long log, a verbose test run. It enters once and costs tokens on every turn after. The accumulated pile itself. Even reasonably sized outputs add up across a long session until the desk is buried. The two tools map onto those two problems. RTK trims the output before it ever reaches the desk. context-mode keeps the heaviest work off the desk altogether. Lay

Started looking for a tourism dataset on Kaggle for a new project. Found one with real UNWTO data, but it only went up to 2022 — not enough for what I wanted (post-COVID trends). Then found a better-looking one: "Global Tourism & Travel Trends (2019-2024)," 24 upvotes, great coverage range. Almost picked it on the spot. Then I actually read the full description. Turns out it's synthetic — 10,000 generated records, not real recorded stats. Had to rename the whole project: from "Travel Recovery Analysis" to "Travel Behavior & Satisfaction Trends (2019-2024)" — same dataset, just honest framing. Still great for practice: 33 features, zero nulls, covers spend, satisfaction, eco-choices, transport modes. Anyone else ever almost build a project around the wrong assumption about their data? 👀

Hello, I'm Shrijith Venkatramana. I'm building git-lrc, an AI code reviewer that runs on every commit. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product. Every developer eventually discovers the same frustrating pattern. Your application sends a 20,000-token prompt to an LLM. The first request takes 2 seconds. The next request contains the exact same 20,000 tokens plus a tiny user message at the end. And somehow the model processes the entire thing again. At least, that's what many developers assume. Modern LLM systems have a trick called prompt caching that can dramatically reduce latency and cost by reusing work from previous requests. But unlike traditional application caches, prompt caching isn't storing generated text. It's storing something much deeper inside the model. To understand how prompt caching works, we need to follow a prompt all the way through the transformer itself. The Expensive Part of Processing a Prompt When a prompt enters a transformer model, it isn't immediately generating text. First, the model must process every input token through every layer of the network. Imagine a prompt like: System: You are a helpful coding assistant. Project Documentation: [20,000 tokens of documentation] User: How does authentication work? Before generating a single output token, the model performs: Tokenization Embedding lookup Multi-head attention Feed-forward networks Layer normalization ...across dozens or even hundreds of transformer layers. For a large model, this preprocessing is often more expensive than generating a short answer. If another user asks: System: You are a helpful coding assistant. Project Documentation: [Same 20,000 tokens] User: Explain the database schema. Most of the prompt is identical. Without caching, the model would recompute everything from scratch. Prompt caching exists to avoid that waste. The Key Insight: Cache Internal Transformer State, Not Text A common misconception

In early 2026, Anthropic researchers ran an experiment with 52 junior developers. Half used an AI assistant to learn an unfamiliar Python library. The other half worked without one. Both groups finished the task. But when tested on how well they understood the code they had just written, the AI-assisted group scored 50% on a comprehension quiz - versus 67% for the unassisted group. That 17-percentage-point gap has a name: cognitive debt. It is one of the most important concepts in software engineering right now, and most developers are not paying enough attention to it. What Is Cognitive Debt? Cognitive debt describes the growing gap between the volume of code that exists in a system and the amount that any developer genuinely understands. It is not a new term, but it crystallized across multiple research streams in early 2026. Addy Osmani (Google Chrome) described it as "comprehension debt" - the hidden cost that accumulates when code becomes cheap to generate but understanding still requires deliberate effort. Margaret-Anne Storey (University of Victoria) formalized the concept in a March 2026 arXiv paper, framing it as a team-level problem and extending it into a Triple Debt Model: technical debt in the code, cognitive debt in the people, and intent debt - the missing rationale that both humans and AI agents need to safely work with code. Cognitive Debt vs. Technical Debt These two ideas are easy to conflate, but they are fundamentally different problems. Technical debt lives in the code - it shows up as slow builds, tangled dependencies, and failing tests. Cognitive debt lives in people - it surfaces as an inability to explain, debug, or extend code that the team themselves wrote. The critical difference: technical debt announces itself through friction. Cognitive debt breeds false confidence. Your tests are green, velocity looks fine, and nobody realizes the system is fragile until something breaks in production and the team cannot reason through why. What the

Hermes Agent already has memory, and that matters. It keeps local context, it improves over time, and it works without forcing you into a cloud service. It also supports several external memory providers. I still built hermes-mempalace , because none of the existing options fit my setup quite right. I wanted something: local-first isolated by Hermes profile verbatim, not just extracted facts easy to inspect on disk simple enough to trust over time That last part is the important one. I did not want a memory layer that turns conversations into an opaque pile of embeddings or summaries you cannot really audit. I wanted actual transcripts, mined into a readable structure, with no hidden server in the middle. Why the existing options were not enough Hermes already gives you a few paths: built-in memory and session context external providers for different use cases enough flexibility to adapt, if you are willing to bend your workflow around them And to be clear, some of those options are good. But ... I run Hermes on a headless machine at home. And I use separate profiles for different contexts. And I do not want conversation content depending on a cloud API or a separate service unless there is a very good reason. So, the best fit had to check a few boxes: [x] no API key [x] no external server [x] no extra runtime I did not already want/install [x] storage isolated by HERMES_HOME [x] memory we can actually read later That let to MemPalace , or https://mempalaceofficial.com/ (hopefully, that's the right one!) What hermes-mempalace does hermes-mempalace wires MemPalace into the Hermes memory provider interface. It follows the same lifecycle as the rest of Hermes memory providers: system_prompt_block() adds a short memory reminder to the prompt. prefetch() can run a MemPalace search before the first model call. sync_turn() buffers completed turns without slowing the chat loop. on_session_end() writes buffered turns to markdown and mines them into the palace. shutdown() flu

The Only Productivity Hack That Actually Worked for Me I've tried every website blocker in existence. They all have the same flaw: one click and they're off. That settings toggle might as well not exist when the urge to procrastinate hits. I needed something I couldn't override. So I built the opposite. The Problem Every blocker follows the same pattern: it blocks, you unblock, you procrastinate. The issue isn't discipline — it's that your future self and your present self want different things. And that future self will happily undo anything you set up. What I needed was a system where both selves agreed on the rules upfront and then neither could break them. The Solution kblocker is a Linux kernel module that hooks into netfilter and drops TCP connections to whatever sites I configure. The key feature isn't the blocking — it's how you turn it off. When blocking is enabled, kblocker generates a 128-bit key. With PGP mode, it automatically encrypts that key to people I trust and then erases it from kernel memory. The raw key no longer exists anywhere on my system. To disable the blocker, one of those people has to decrypt it and send it back to me. I outsourced my willpower. When I want to focus, I run: sudo kblockerctl enable 120 Two hours of blocked distractions. If I feel the urge to procrastinate, I can't — I'd have to text a friend, explain why, wait for them to decrypt it, and paste the result. By then the urge is gone. The Result I've gone from losing entire afternoons to YouTube to actually finishing things. The blocker has caught me mid-reflex to type youtube.com more times than I can count. It's free if anyone wants it: github.com/Dan-J-D/kblocker If you keep breaking your own focus tools, this is for you.

For a long time I found myself checking different European stores to see where products were cheapest. It was slow and annoying. I had to open lots of tabs, change countries, check delivery costs and compare prices myself. I used other comparison websites, but I wanted something simpler. So I decided to build Haggl.eu. Haggl lets you compare prices across Europe from one search, helping you find better deals and save money. This is my first public project and I am learning a lot while building it. The site is still a work in progress, but I have plenty of ideas for the future. I want to add more stores, more countries, price history tracking and better delivery comparisons. My goal is to make it as easy as possible to find the best deal without spending ages clicking through different pages. I would love to hear any feedback or suggestions. Thank you everyone :) https://haggl.eu