🐥 YellowDuck.be

🔗 When AI costs more than the engineer

2026-07-15T13:00:00Z

Anthropic spends an astonishing 2.3 times its payroll on compute, averaging $515,000 per engineer annually against a typical fully-loaded salary of $224,000. The article dives into the computational expenditures of top AI firms compared to the broader software market. For context, while leading companies allocate $89,000 per engineer on AI tools, the median sits at just $137. Three scenarios are presented for how this spending gap could close by 2029. The Bull case predicts a future where AI costs per engineer soar to levels matching a full SaaS employee's contribution, emphasizing a dramatic shift in the cost structures of AI-native firms. With companies like Anthropic and OpenAI already leading with high revenue-per-employee, the implications for the broader market are substantial. As the intersection of salary and AI expenditure becomes crucial, the article urges readers to consider their strategic position in this evolving landscape.

Continue reading on tomtunguz.com

#reading-list #development #ai #devops

🔗 Introducing Podman v6.0.0

2026-07-15T08:00:00Z

Podman v6.0.0 has landed, bringing substantial improvements to container management. This release modernizes networking with the transition to Netavark and nftables, enhancing security and user experience. Significant updates to Podman Machine ensure seamless operations across VM providers, while the revamped quadlet features make management easier with new REST API support. The updated configuration file handling improves multi-user administration, and compatibility with Docker has been refined to ease transitions. Users are encouraged to explore these features and share feedback, highlighting the community's role in the project's success.

Continue reading on blog.podman.io

#reading-list #devops #announcement #docker

🔗 Understanding is the new bottleneck

2026-07-14T17:00:00Z

Agents are increasingly handling code generation, leading to a growing gap in human understanding. This article delivers insights from a talk presented at the AI Engineer conference which argues why comprehending the code written by AI is becoming essential. Techniques for fostering this understanding include employing structured code explainers, interactive quizzes to ensure comprehension, and creating micro-worlds that simulate coding environments. By actively engaging with these strategies, individuals can not only verify what their agents produce but also participate meaningfully in the creative process. With AI evolving to handle more tasks, the discussion revolves around how humans can adapt and deepen their understanding of technology rather than just stepping back.

Continue reading on www.geoffreylitt.com

#reading-list #development #best-practice #ai

🔗 Does a url in a prompt steer an llm's output toward its content?

2026-07-14T13:00:00Z

Does the inclusion of a URL in a prompt influence the output of a language model? Paul Kinlan explored this question through experiments on LLM responses to various URLs. He found that URLs can have an impact, but only if their content is part of the model's training data. Significant observations included that JavaScript-heavy sites often produce no recall, while descriptive URLs help guide output effectively. Kinlan demonstrated that opaque URLs generally perform poorly, while some well-known identifiers show high accuracy. This raises concerns about how data is gathered for training models. The exploration reveals a complex interaction between prompts and language model outputs, highlighting the necessity for transparency in LLM training data.

Continue reading on aifoc.us

#reading-list #http #ai

🔗 Our new product strategy for Wagtail

2026-07-14T08:00:00Z

Today’s announcement details Wagtail's new product strategy, laying out a vision for future development. With over a decade in competition, Wagtail has evolved to meet the demands of AI adoption thoughtfully, shifting from a purely AI-first approach to responsible and intentional integration. Key focuses include future-ready content management, seamless integrations, and a strong Developer Experience (DX). The roadmap for Wagtail 8.0 features a new "write" API for smoother content operations and ongoing enhancements in security and flexibility. The community is encouraged to contribute to this ambitious strategy, highlighting the collaborative nature of open source development. Engagement through events like Wagtail Space 2026 is also emphasized, aiming to unite developers, maintainers, and users in this journey.

Continue reading on wagtail.org

#reading-list #development #ai #wagtail #announcement

🔗 Why Svelte is better than React in the AI era

2026-07-13T17:00:00Z

Why is Svelte overshadowing React in the growing landscape of AI technologies? Zack Webster highlights how Svelte’s reactive nature offers superior performance and user experience. He explains that Svelte compiles to highly optimized JavaScript, reducing runtime overhead that often hinders React applications. This efficiency is crucial when building apps that leverage AI features, where speed and responsiveness are paramount. Webster also points out Svelte’s simplicity in syntax and state management, making it more approachable for developers, especially those transitioning from different frameworks. As AI integration intensifies, Svelte's ability to deliver a seamless interface will likely position it as a go-to choice in modern web development.

Continue reading on out.reddit.com

#reading-list #javascript #frontend #ai

🔗 The only scalable delete in Postgres is DROP TABLE

2026-07-13T13:00:00Z

Counterintuitively, large deletes add work to the database. Experience shows that scalable Postgres data-deletion strategies involve removing entire tables rather than executing individual row deletes. While small-scale deletes can be manageable, large batch operations lead to significant overhead without freeing physical disk space, causing impact on performance and replication processes.

DROP TABLE and TRUNCATE are recommended alternatives, as they scale better and free space efficiently. These methods bypass the issues of dead tuples and vacuum debt, which bog down traditional delete operations. In practice, a temporary table approach for retaining essential data during deletions is suggested, allowing for swift data management without prolonged locks. As partitioning capabilities improve with newer Postgres versions, structuring data to facilitate DROP TABLE operations can drastically enhance database performance, reducing latency and replication strain.

Continue reading on planetscale.com

#reading-list #database #best-practice #postgresql

🔗 The artisan dev command in Laravel 13.16.0

2026-07-13T08:00:00Z

A new php artisan dev command in Laravel 13.16.0 allows developers to run multiple processes concurrently, such as the server, queue worker, log tailing, and Vite. This command streamlines development by integrating configuration directly into application code. The release also introduces the whenFilledEnum() method for handling typed enums directly in requests, and the withCookies() method has been extended to allow attaching multiple cookies to any response type. Additionally, a new array-based maintenance mode driver enhances parallel testing capabilities by avoiding conflicts with the existing file and cache drivers. Other improvements cover enum handling in event broadcasting and updates to JSON schema support. Developers are encouraged to upgrade to v13.16.1 for fixes related to the new command.

Continue reading on laravel-news.com

#reading-list #development #laravel #tools

🔗 The 37signals guide to making decisions

2026-07-12T17:00:00Z

A company is fundamentally defined by its decisions and the people who make them. This guide from 37signals outlines a clear framework for decision-making tailored for business contexts. It presents thoughtful questions to ask before making decisions, such as whether the right person is involved, the implications of hesitation, and if smaller decisions can stem from larger ones. The guide emphasizes a balance of data-driven choices and gut instincts, while questioning the impact of decisions on others. It encourages reflecting on past decisions for better future outcomes, showcasing a structured yet flexible approach to navigating choices in a business environment. Additional resources on communication and project management are also highlighted, reinforcing the interconnected nature of decision-making and organizational success.

Continue reading on 37signals.com

#reading-list #development #best-practice

🔗 Lies, damn lies and database benchmarks

2026-07-12T13:00:00Z

Benchmarks often mislead the tech community, leading to skewed perceptions of database performance. Andrey Pechkurov, a Core Database Engineer, illustrates how database benchmarks, like ClickBench, resemble a chaotic contest where the rules don’t always equate to true performance measurement. By examining the ClickBench benchmarking process, Pechkurov reveals the challenges of comparing different database engines. The article emphasizes the importance of understanding how benchmarks run and how they can be manipulated based on the environments in which databases operate. This piece stands as a critical commentary on how numbers can misrepresent reality in database performance comparisons, particularly revealing insights about the cold versus hot run metrics, and what these mean for hosted versus self-managed systems. Pechkurov’s findings serve as a reminder that while benchmarks are valuable tools, they should be interpreted with a discerning eye.

Continue reading on questdb.com

#reading-list #database #best-practice

🔗 Cleaning up after AI rockstar developers

2026-07-12T08:00:00Z

Why do teams often struggle after a talented developer leaves? Jesse Skinner delves into the chaos left behind by AI rockstar developers who produce impressive yet incomprehensible code. Their abrupt departures can lead to significant technical debt, leaving others grappling with tangled, hard-to-follow systems. Skinner outlines the challenges faced when taking over such projects, revealing how AI can amplify the complexity and create a chaotic codebase. He offers strategies for managing this complexity, suggesting ways to work alongside AI without compromising code clarity. The discussion emphasizes craftsmanship and highlights the need for quality over speed, urging developers to lead with intent and maintain code that is understandable and maintainable.

Continue reading on www.codingwithjesse.com

#reading-list #development #best-practice #ai

🔗 Draw the rest of the ___ owl (software factory edition)

2026-07-11T17:00:00Z

How can a software development team trust the code generated by LLMs without reviewing it? This article dives into the challenges teams face as they navigate using LLMs like OpenCode and Claude Code, which may diminish the role of human oversight in coding. It emphasizes the importance of verification, suggesting that simply providing context isn't enough to ensure reliable software factories. The author proposes that automated tests written by LLMs must be validated, advocating for a system of "sensors" to monitor application behavior, code quality, and architectural integrity. Additionally, tools like Gherkin scenarios, boundary libraries for Elixir, and static analysis are discussed as potential solutions for maintaining software health. Ultimately, the need for comprehensive feedback mechanisms is highlighted to create a sustainable workflow, whether or not teams fully adopt a software factory model.

Continue reading on www.germanvelasco.com

#reading-list #development #ai #testing

🔗 How to safely delete records in massive tables on AWS using Laravel

2026-07-11T13:00:00Z

When handling massive databases, like Flare's table with 1 billion records, a naive DELETE can lead to disastrous locks. A straightforward delete could halt your app for hours. Instead, employing a LIMIT can speed up deletions, releasing locks faster. However, AWS Lambda's 15-minute execution time limit complicates things, necessitating a job queue for longer processes. By using CleanTableJob, the deletion tasks can self-dispatch, ensuring they run smoothly without overwhelming the system. Additionally, implementing an atomic lock prevents overlapping jobs, offering a reliable setup for managing large tables. Overall, this approach effectively balances database integrity and performance, ensuring efficient record management on AWS.

Continue reading on flareapp.io

#reading-list #laravel #database #best-practice #devops

🔗 Add a second remote origin with Git

2026-07-11T08:00:00Z

Sometimes you need a second remote origin for a project, especially if it involves auto deployment and access limitations. Hamid Shoja outlines the steps to add a second remote origin in Git where syncing with the primary origin is crucial. The process begins by using git remote add to add the additional origin, followed by using git push --all to push changes to both remote repositories. The article also highlights how to sync changes between the two origins with commands like git fetch and git merge, ensuring that both repositories remain aligned. This is particularly useful for developers needing flexibility in managing their code with multiple repositories.

Continue reading on dev.to

#reading-list #development #best-practice #git

🔗 Why dead code feels hard to delete

2026-07-10T17:00:00Z

It’s a common challenge when developers hesitate to delete dead code, often due to the sunk cost fallacy or loss aversion. The sunk cost fallacy leads us to believe that since we invested time and effort into writing code, it holds inherent value. However, this line of thinking can lead to increased complexity and future costs. The loss aversion principle further complicates matters, as losing code feels worse than never having it at all, even if it's unused. Understanding these cognitive biases sheds light on why teams cling to dead code and emphasizes the need to view code as a liability, not a resource. Minimizing unnecessary code leads to more clarity and lower maintenance costs, ultimately helping teams serve their customers better.

Continue reading on www.germanvelasco.com

#reading-list #development #best-practice

🔗 Docker alternative: Podman on Linux

2026-07-10T13:00:00Z

Podman presents a compelling alternative to Docker, especially for Linux users. This article outlines how Podman operates without a central daemon, making it more secure and flexible by allowing rootless container execution. Readers learn the straightforward installation process, using common commands like podman run and podman ps, and the benefits of managing containers through systemd with Quadlets. Comparisons with Docker show Podman’s advantages, particularly in security and alignment with Linux philosophy, while also acknowledging Docker’s extensive ecosystem. It's a practical guide for anyone considering a switch or starting containerization on Linux systems with a focus on efficiency and improved security.

Continue reading on linuxblog.io

#reading-list #devops #linux #docker #sysadmin

🔗 Six SQL patterns I use to catch transaction fraud

2026-07-10T08:00:00Z

Fraud detection largely relies on SQL rather than machine learning or hype-driven technologies. The author shares six effective SQL patterns applicable to various transaction systems, from credit cards to e-commerce. The first pattern addresses velocity, identifying rapid usage of a stolen card, suggesting fraud. The second pattern, impossible travel, flags transactions occurring in far-apart locations within an implausibly short time frame. Another pattern identifies amount anomalies where specific transaction amounts correlate strongly with fraudulent behavior. The article also highlights suspicious merchants exhibiting unusual activity and off-hours spending, which indicates potential unauthorized use. Finally, a framework involving window functions allows for more complex fraud detection by aggregating signals from these patterns. The author notes that utilizing these patterns collectively enhances the ability to uncover fraudulent transactions effectively. This practical SQL-focused approach provides a foundation for building robust fraud detection mechanisms.

Continue reading on analytics.fixelsmith.com

#reading-list #pattern #best-practice #sql

🔗 Stop mounting your LiveView twice

2026-07-09T17:00:00Z

Every LiveView mounts twice on the first page load—once for the static HTTP "dead render" and again when the WebSocket connects. This can lead to unnecessary database queries and performance hits. The recommended fix is to use connected?/1 to conditionally load data during the connection, but this approach has its drawbacks. It still results in duplicate processing when mounting and can hinder SEO and user experience by leading to an empty first paint.

The article outlines the limitations of this conventional solution and highlights ongoing efforts by the Phoenix team to improve LiveView's handling of mounts via the adoption of LiveViews. This new approach aims to keep the LiveView process alive across connections, avoiding the need for multiple mounts altogether, enhancing performance and reliability. By addressing these challenges, developers can create more efficient LiveViews without compromising on initial page load quality or SEO prioritization.

Continue reading on elixirdrops.net

#reading-list #best-practice #elixir #phoenix

🔗 Stop programming in Markdown

2026-07-09T13:00:00Z

Amidst the rising hype around AI, particularly LLMs, companies misuse these tools in scenarios where traditional code is far superior. This translates to programming in Markdown, relying on LLMs to interpret logic with slow, costly, and insecure performance. Tasks often solvable with straightforward code are overcomplicated by using prompted LLMs. Examples like automating e-commerce returns illustrate a misuse of LLMs when simple code suffices. Additionally, the allure of LLMs often stems from their ability to simplify interactions, making them tempting despite their inefficiencies. The article emphasizes the need to resist using LLMs needlessly and to leverage traditional programming for common business processes. It calls for a reevaluation of when and how LLMs should be integrated into systems, pointing out the risks and inefficiencies of relying on them when simpler solutions exist.

Continue reading on structural.chat

#reading-list #development #best-practice #ai

🔗 Modern CSS theming with light-dark(), contrast-color(), and style queries

2026-07-09T08:00:00Z

This article dives into a novel dynamic theming system using new CSS features. It introduces light-dark() for switching between light and dark color schemes based on user preferences, while contrast-color() ensures optimal text visibility against varying backgrounds. The author combines these functions with @container style() to create customizable color palettes, enhancing both accessibility and aesthetics. Practical examples illustrate how to implement shadows in light mode and glowing borders in dark mode, ensuring that UI elements are visually appealing and readable irrespective of the theme. This innovative approach allows developers to craft intricate themes that respect user settings while providing a fluid user experience. Everything is browser-compatible as of May 2026, making this a timely exploration into modern CSS capabilities.

Continue reading on una.im

#reading-list #frontend #css #best-practice

🔗 Mistral OCR 4 : SOTA OCR for Document Intelligence

2026-07-08T17:00:00Z

Mistral AI has released Mistral OCR 4, touting its ability to extract and structure content from documents with exceptional accuracy. This model supports 170 languages and is designed for self-hosted deployments, ensuring compliance and sovereignty. It introduces features like bounding boxes, block classification, and inline confidence scores, tackling the weaknesses of previous OCR generations. Human evaluations showed that independent annotators preferred OCR 4, achieving a win rate of 72% against leading systems, while delivering an impressive overall score on OlmOCRBench (85.20). The model facilitates enhanced document processing for tasks like retrieval-augmented generation and agentic workflows, marking a significant step forward in document intelligence.

Continue reading on mistral.ai

#reading-list #tools #ai #devops

🔗 In memory of the man who put red and green squiggles under words

2026-07-08T13:00:00Z

Tony Krueger, whose contributions went largely unrecognized, passed away recently. He is best known for implementing the red and green squiggles in Microsoft Word that alert users to spelling and grammatical errors. These features transformed how people interacted with word processors, shifting from interruptive spell checks to an unobtrusive system that highlights mistakes as they occur. Krueger's work on various versions of Word helped pave the way for modern writing tools in nearly every application today. His innovative approach not only improved user experience but also earned him an unexpected moment of fame when Penn & Teller acknowledged his work. While often overlooked, Krueger's legacy continues to impact users across the globe every time they see a red squiggle beneath a misspelled word. The next time this happens, remember to thank Tony.

Tony also reverse-engineered and ported the game Chip’s Challenge to Windows, showcasing his technical prowess before his fame in word processing began.

Continue reading on devblogs.microsoft.com

#reading-list #tools

🔗 Key activities for sustainable engineering team

2026-07-08T08:00:00Z

What signals indicate it's time for managers to change their operational focus? In a compelling article, Dunya Kirkali breaks down the essential activities that engineering managers must prioritize for effective team management. The piece categorizes these activities into internal, boundary, and external groups, emphasizing that synchronization meetings, reflections, and planning sessions are key for internal cohesion. Managers need to be attuned to their team's momentum through regular retrospectives and syncs. Boundary activities, such as ops reviews and business reviews, ensure alignment with organizational goals while external activities—like market research and customer feedback—provide necessary context. This framework enables managers to know when to shift their attention, ensuring teams can deliver effectively without micromanagement. Managers are encouraged to focus not just on the tasks at hand but on the signals that reveal deeper insights about their team’s dynamics.

Continue reading on blog.incrementalforgetting.tech

#reading-list #development #best-practice

🐥 How to start and enable ClamAV service on Linux

2026-07-07T17:00:00Z

ClamAV is a powerful, open-source antivirus engine designed to detect malware, viruses, and trojans on Linux systems. If you have just installed it, you need to start its background services so that it can protect your system and keep its virus definitions up to date.

This guide will show you how to start, enable, and verify the ClamAV services using systemctl.

Prerequisites

Before running the commands, ensure you have:

A Linux distribution installed.
Administrative privileges (sudo or root access).

Step 1: Start the Antivirus Daemon

The primary service is clamav-daemon. This background process loads virus signatures into memory and handles on-access scanning. It also allows you to run high-speed scans using the clamdscan utility.

Run the following commands in your terminal:

Start the service:
```
sudo systemctl start clamav-daemon
```
Enable it to start automatically on boot:
```
sudo systemctl enable clamav-daemon
```
Verify that it is running correctly:
```
sudo systemctl status clamav-daemon
```

💡 Note: The daemon might take a few moments to change to an "active" status. This delay happens because it is loading a large database of malware definitions directly into your system's RAM.

Step 2: Start the Automatic Database Updater

An antivirus engine is only as good as its virus signatures. ClamAV uses a separate service called clamav-freshclam to look for and download the latest malware definitions automatically.

To get the updater running, execute these commands:

Start the updater service:
```
sudo systemctl start clamav-freshclam
```
Enable the updater to start on boot:
```
sudo systemctl enable clamav-freshclam
```
Verify the update status:
```
sudo systemctl status clamav-freshclam
```

Conclusion

Your Linux machine is now running ClamAV in the background with continuous, automated database updates. You can now safely run manual system scans or configure real-time protection.

#terminal #linux #sysadmin

🔗 Build a document processing workflow in 30 minutes

2026-07-07T13:00:00Z

Workflows is an orchestration platform for building, executing, and monitoring complex AI-driven workflows. It provides durable, fault-tolerant workflow execution backed by battle-tested distributed systems infrastructure, combined with a developer-friendly SDK.

In this tutorial, you’ll build an end-to-end medical document processing pipeline using three Mistral capabilities: OCR to read PDFs, Agents to classify documents and extract structured data, and Workflows to orchestrate the entire process reliably.

The pipeline takes any scanned medical PDF like a prescription, a hospital bill, or an imaging report and runs it through three steps: optical character recognition (OCR) to extract raw text, an AI agent to classify the document type with a confidence score, and a second agent to extract patient information and document-specific fields as structured JSON. Because it’s built on Mistral Workflows, each step is durable and fault-tolerant: if a worker restarts mid-execution, the workflow resumes where it left off instead of starting over.

You’ll also include a human-in-the-loop step: when the classifier’s confidence falls below a configurable threshold, the pipeline pauses and waits for a user to review and confirm the category before extraction continues. Mistral Workflows enables these long-running processes that can pause and resume based on external input, which is difficult to build reliably with a simple async queue or a chain of API calls.

Continue reading on x.com

#reading-list #pdf #development #ai