🐥 YellowDuck.be

🔗 Comparison of AI models across intelligence, performance, and price

2026-04-25T13:00:00Z

This post presents a comprehensive comparison of 429 AI models across intelligence, performance, and pricing metrics. Gemini 3.1 Pro Preview and GPT-5.4 (xhigh) lead in intelligence, while Mercury 2 and Granite 3.3 8B offer the fastest output speeds at 794 and 435 tokens per second respectively.

The analysis reveals significant price-quality variance across models, with Gemma 3n E4B and LFM2 24B A2B offering the lowest costs at $0.03 and $0.05 per million tokens. Latency performance is dominated by Gemini 2.5 Flash-Lite variants, while Llama 4 Scout provides the largest context window at 10 million tokens.

Continue reading on artificialanalysis.ai

#reading-list #tools #ai

🔗 chenglou/pretext: Fast, accurate & comprehensive text measurement & layout

2026-04-25T08:00:00Z

I discovered Pretext, a pure JavaScript/TypeScript library for multiline text measurement and layout. It eliminates the bottleneck of DOM measurements that can cause expensive layout reflows by implementing its own text measurement logic using the browser's font engine. I can quickly measure a paragraph's height without interacting with the DOM by using prepare() and layout().

The library is versatile, allowing rendering to DOM, Canvas, or SVG, and it supports complex use cases such as dynamic layouts and rich-text inline flows. Developers can efficiently control line layouts and manage text statistics, which reduces development time and prevents layout shifts. This library opens up new possibilities for crafting sophisticated UI layouts without the usual CSS constraints.

Continue reading on github.com

#reading-list #javascript #typescript #frontend #tools

🔗 Learning Elixir: error handling basics

2026-04-24T13:00:00Z

I learned how Elixir’s error handling resembles a reliable postal service: every package returns either {:ok, value} for success or {:error, reason} for failure. Unlike many languages that predominantly rely on exceptions, Elixir treats errors as first-class values that streamline control flow. This makes the code more explicit and logical, especially for newcomers. In practice, functions consistently return tuples that describe success or failure. For example, using pattern matching, you can easily differentiate between successful results and errors, enhancing readability. The same conventions are followed throughout Elixir’s standard library, reinforcing consistency. I've found that using with to chain operations while maintaining clarity is particularly effective when managing multiple function calls that might fail. Overall, integrating these patterns promotes building robust and maintainable applications in Elixir.

Continue reading on dev.to

#reading-list #pattern #best-practice #elixir

🔗 Rob Pike's 5 Rules of Programming

2026-04-24T08:00:00Z

Rob Pike's five rules of programming provide foundational advice for developers of all levels. The first rule emphasizes not to preemptively optimize without evidence of bottlenecks. Rule two reinforces the importance of measurement before tuning for speed, making it clear that one must understand performance before making changes. The third and fourth rules caution against the overuse of complex algorithms, especially when datasets are small, promoting the wisdom of simplicity. Finally, rule five highlights the importance of data structures over algorithms, encapsulating the idea that well-organized data leads to more straightforward coding solutions. Pike's ideas echo the sentiments of legends like Tony Hoare and Fred Brooks, reinforcing a timeless programming philosophy: prioritize clarity and relevance over complexity.

Continue reading on www.cs.unc.edu

#reading-list #development #best-practice

🔗 Samly SAML Single-Sign-On for Elixir Phoenix

2026-04-23T17:00:00Z

The samly library provides SAML Single-Sign-On authentication specifically for Plug/Phoenix applications. With version 1.4.0, it showcases solid download statistics, hitting over 1.8 million total downloads and 675,030 for the most recent update. This tool leverages popular build tools like mix and stands under the MIT license, ensuring its maintenance and open-source flexibility. It offers a straightforward implementation for developers looking to integrate SAML authentication without overcomplication. The latest version was released on January 29, 2024, highlighting ongoing support and updates. So if you're seeking to improve your app's authentication flow securely, samly might be the solution you need.

Continue reading on hex.pm

#reading-list #elixir #phoenix #auth

🔗 Encoding Team Standards

2026-04-23T13:00:00Z

AI coding assistants are only as effective as the prompts they receive. I found that many developers, especially juniors, struggle to articulate team standards, leading to inconsistent outputs. This inconsistency is not simply a skills gap; it’s a systematic problem. More experienced developers instinctively apply best practices when interacting with AI, but junior developers often don’t know what to ask for, resulting in variances in code quality.

To solve this, I propose turning team standards into versioned, executable instructions, shared as artifacts that AI can consistently apply. By encoding our tacit knowledge into structured prompts, we ensure that standards are executed as part of the development workflow, rather than simply memorized. This way, the team’s judgment is applied equally, regardless of who is working on a task. The insights gained from formalizing these instructions also highlight discrepancies among team members about critical security and architectural concerns, leading to more aligned and effective practices throughout the team.

Continue reading on martinfowler.com

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

🔗 Different flavors of content management

2026-04-23T08:00:00Z

Most people underestimate the variety of content management systems (CMS), which are generally classified as either monolithic or headless. A monolithic CMS, like WordPress or Drupal, manages both data and presentation, making it simpler for users. In contrast, headless CMS like Strapi only handles data management and offers an API, allowing for more flexibility in technology choices but requiring additional setup.

Another classification is by hosting type: self-hosted options, like Statamic, offer complete control over data but demand more effort for maintenance and security. Conversely, SaaS solutions, such as Webflow, alleviate operational burdens but come with risks like feature limitations and potential service sunsets. Understanding these distinctions is crucial in selecting the right CMS for specific needs, whether as a simple site builder or a complex application framework.

Continue reading on maciekpalmowski.dev

#reading-list #development #tools #best-practice

🔗 AI is writing our code faster than we can verify it

2026-04-22T17:00:00Z

Most experienced developers don’t trust AI-generated code, and for good reason. While AI can produce code faster than ever, reliability remains a significant concern. I found this reinforced by a statistic showing that trust in AI coding tools plummeted to just 33% from over 70% in two years. The surprising truth is this steep decline isn’t as straightforward as claimed; two different surveys muddled the context to create a concerning narrative. The actual situation reflects a common experience—AI often generates code faster than we can properly verify it. I observed this gap leading many senior engineers to avoid using AI for crucial tasks, instead relying on it for less critical processes like unit tests. The solution isn’t just adopting better testing tools, but also reintroducing quality engineering practices that can harness AI’s strengths while ensuring code integrity.

Continue reading on www.oreilly.com

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

🔗 Thoughts and Feelings around Claude Design

2026-04-22T13:00:00Z

I tried Claude Design and it exposed some uncomfortable truths about Figma. As design teams push for systematization, Figma created complex primitives that blend programming concepts with design. This has led to headaches in back-porting design changes to code — it's both inefficient and unnecessarily complicated. The underlying issue is that Figma's rigid system isn't staying relevant in the age of LLMs, which are trained on code, not design files.

I'm intrigued by Claude Design because it embraces HTML and JavaScript directly. This honesty about its code foundation allows for a faster feedback loop between design and implementation, unlike Figma Make, which still clings to its proprietary structures. The tension is palpable; as Claude navigates this shift, I wonder which other tools will emerge to redefine the design landscape. It's a pivotal moment that signals a shift away from Figma's dominance.

Maybe we're looking at a new era of design tooling that truly delivers on speed and flexibility instead of complexity and confusion.

Continue reading on samhenri.gold

#reading-list #frontend #tools #ai

🔗 Hosting PR previews on GitHub Pages for free

2026-04-22T08:00:00Z

GitHub Pages offers a free way to host static websites, usually at a single URL per repository. However, it presents challenges when trying to preview pull requests (PRs). Instead of relying on third-party services for PR previews, I discovered a workaround by hosting them within the main GitHub Pages site under subdirectories named after the PR numbers.

When a PR is opened, a GitHub Actions workflow automates the deployment of the site to a URL like https://.github.io//previews/pr-123/. This method allows for quick previews, albeit with caveats such as managing relative asset paths and updating the robots.txt file to prevent indexing. I implemented two workflows: one for deploying PR previews upon opening or updating a PR and another for deploying the main site when changes are merged. This approach streamlines my process without relying on external services.

Continue reading on blog.danskingdom.com

#reading-list #tools #devops #github

🔗 Thinking Elixir Podcast 300: Celebrating 300 with José Valim

2026-04-21T17:00:00Z

Episode 300! News includes the Localize library v0.15.0, a new program dependence graph tool called Reach, Tidewave voice input and PWA support, ERLEF 2026 elections, plus a special in-depth interview with José Valim!

Continue reading on podcast.thinkingelixir.com

#reading-list #elixir #phoenix

🔗 How I'm Productive with Claude Code

2026-04-21T13:00:00Z

The author's productivity with Claude Code has dramatically increased through systematic automation and infrastructure improvements. By delegating grunt work like PR creation to agents and removing friction points in the development workflow, the author shifted from being an implementer to managing a team of AI agents.

Key optimizations included automating PR formatting with a /git-pr skill, switching to SWC for sub-second server rebuilds, enabling Claude Code's preview feature for UI verification, and building a port-management system for parallel worktrees. Each friction removal revealed the next bottleneck, following the theory of constraints and creating a tight feedback loop that keeps focus unbroken.

Continue reading on neilkakkar.com

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

🔗 MrPopov :: Python React to Elixir Phoenix Migration Breakdown

2026-04-21T08:00:00Z

The migration from a Python/React/Zeebee microservices architecture to a Phoenix monolith achieved a 63% reduction in code and eliminated nine entire technology layers. By simplifying the stack, this post highlights significant improvements in compliance-related processes, as the reduced number of services and dependencies lessens the complexity for audits.

Continue reading on mrpopov.com

#reading-list #javascript #development #python #elixir #phoenix

🔗 The 8 levels of agentic engineering

2026-04-20T17:00:00Z

AI's coding ability is outpacing our ability to wield it effectively. That's why all the SWE-bench score maxxing isn't syncing with the productivity metrics engineering leadership actually cares about. When Anthropic's team ships a product like Cowork in 10 days and another team can't move past a broken POC using the same models, the difference is that one team has closed the gap between capability and practice and the other hasn't.

That gap doesn't close overnight. It closes in levels. 8 of them. Most of you reading this are likely past the first few, and you should be eager to reach the next one because each subsequent level is a huge leap in output, and every improvement in model capability amplifies those gains further.

The other reason you should care is the multiplayer effect. Your output depends more than you'd think on the level of your teammates. Say you're a level 7 wizard, raising several solid PRs with your background agents while you sleep. If your repo requires a colleague's approval before merge, and that colleague is on level 2, still manually reviewing PRs, that stifles your throughput. So it is in your best interest to pull your team up.

From talking to several teams and individuals practicing AI-assisted coding, here's the progression of levels I've seen play out, imperfectly sequential.

Continue reading on www.bassimeledath.com

#reading-list #ai

🔗 Software engineer interviews for the age of AI

2026-04-20T13:00:00Z

Great engineers are essential because knowledge expands fractally, and production systems require accountability beyond plausible code. People pay for reliable services, not homework assignments, so engineers must own the systems they build with their phone number on the line.

Interview design should assess fractal knowledge through follow-up questions on past projects, revealing what candidates truly understand versus what they merely read about. System design interviews expose hands-on experience versus theoretical knowledge, while coding interviews with real tools, documentation, and AI access test whether candidates can ship working solutions that handle operational concerns and scale.

Leetcode problems are too clean and chewed up to reflect real work, which requires understanding business domains and talking to people. The ideal coding interview provides a stubbed codebase, clear business problem, API documentation, and permission to use AI, Google, and pair with the interviewer to build a working script that reads and writes to databases and third-party APIs.

Continue reading on swizec.com

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

🔗 AshEvents: Event sourcing made simple for Ash framework

2026-04-20T08:00:00Z

AshEvents is an extension for the Ash Framework that brings first-class event sourcing capabilities to your applications. It simplifies the process of tracking and replaying events, making it easier to manage historical data and debug complex systems.

Continue reading on alembic.com.au

#reading-list #elixir

🔗 What is Claude Code's AskUserQuestion tool?

2026-04-19T17:00:00Z

The AskUserQuestion tool in Claude Code enhances the development process by allowing AI to ask clarifying questions during coding sessions. This method eliminates assumptions, leading to code that better matches user intent from the start.

Using a structured process of interviewing to build specifications and then executing them ensures clarity and precision. This integration with Linear not only facilitates asynchronous team collaboration but also preserves context and improves visibility into decision-making throughout the development lifecycle.

Continue reading on www.atcyrus.com

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

🔗 Comprehension debt - the hidden cost of AI generated code

2026-04-19T13:00:00Z

Comprehension debt is the hidden cost to human intelligence and memory resulting from excessive reliance on AI and automation. For engineers, it applies most to agentic engineering.

There’s a cost that doesn’t show up in your velocity metrics when teams go deep on AI coding tools. Especially when its tedious to review all the code the AI generates. This cost accumulates steadily, and eventually it has to be paid - with interest. It’s called comprehension debt or cognitive debt.

Comprehension debt is the growing gap between how much code exists in your system and how much of it any human being genuinely understands.

Unlike technical debt, which announces itself through mounting friction - slow builds, tangled dependencies, the creeping dread every time you touch that one module - comprehension debt breeds false confidence. The codebase looks clean. The tests are green. The reckoning arrives quietly, usually at the worst possible moment.

Continue reading on addyosmani.com

#reading-list #golang #tools #ai

🔗 11 software development best practices in 2026

2026-04-19T08:00:00Z

Discover essential software development best practices to enhance code quality, efficiency, and maintenance, featuring principles like DRY and YAGNI.

Best Practices for Software Development in 2026

Software development is a constantly evolving field, and adopting the right practices can significantly improve the quality and maintainability of your code. Here are some of the best practices that you should implement in your software development processes in 2026:

DRY (Don't Repeat Yourself):
Reducing repetition within your codebase enhances clarity and minimizes maintenance efforts.

YAGNI (You Aren't Gonna Need It):
Avoid implementing features until they are necessary. This practice helps in keeping the codebase clean and manageable.

KISS (Keep It Simple, Stupid):
Aim for simplicity in your designs and implementations. Overcomplication can lead to more bugs and harder maintenance.

Continue reading on www.netguru.com

#reading-list #development

🔗 Tower 16 for Mac (Beta) — Introducing AI commits ✨

2026-04-18T17:00:00Z

Say goodbye to tedious commit messages! Tower 16 for Mac introduces AI Commits, allowing users to generate commit messages and descriptions effortlessly using AI right from their Git client. With the new Generate button in the Commit Composing area, I can stage changes and click to get instant suggestions for commit messages. Tower 16 also supports two AI providers—Claude Code and OpenAI's Codex—which I can configure in the new AI tab under settings. I can even create custom prompt presets for my team's specific commit conventions, ensuring consistency and clarity. The update includes handy features in the Working Copy view, and improvements such as clickable URLs in the License View and better performance with large branches. Overall, this beta makes my Git workflow smoother and more efficient!

Continue reading on www.git-tower.com

#reading-list #tools #ai #announcement #git #mac

🔗 Production query plans without production data

2026-04-18T13:00:00Z

This article examines how PostgreSQL 18 introduces enhancements for managing optimizer statistics without the need for production data. The features pg_restore_relation_stats and pg_restore_attribute_stats enable users to inject statistics directly into the catalog tables, facilitating the creation of test environments that mimic production systems in terms of query planning and execution.

By using these functions, developers can export statistics from a production database and reproduce them in development or testing contexts, improving the accuracy of performance assessments. This capability addresses the challenges posed by differing row configurations in production and CI environments, allowing for reliable query plan validations and potential optimizations based on real-world data distributions.

Continue reading on boringsql.com

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

🔗 mickamy/sql-tap: Watch SQL traffic in real-time with a TUI

2026-04-18T08:00:00Z

sql-tap is a real-time SQL traffic viewer that functions as a proxy daemon and terminal user interface (TUI). It captures and displays queries from PostgreSQL, MySQL, or TiDB without requiring application code changes, offering features like query inspection and EXPLAIN commands.

Installation is straightforward across different platforms, including Homebrew, Docker, and building from source. Users can start the proxy daemon and connect their applications seamlessly to view live SQL traffic through the TUI or web interface, with options for real-time monitoring of N+1 and slow queries.

Continue reading on github.com

#reading-list #database #tools #devops #sql #terminal

🔗 SFQ: Simple, Stateless, Stochastic Fairness

2026-04-17T17:00:00Z

Stochastic Fairness Queuing (SFQ) offers a method to effectively manage workloads in distributed systems by utilizing a fixed set of queues. By hashing customer identifiers to this limited number of queues, SFQ mitigates the negative impact of noisy neighbors while maintaining O(1) performance for both enqueueing and dequeueing requests.

The proposal combines SFQ with shuffle sharding and a best-of-two algorithm to optimize request handling further. This approach enhances customer isolation from noisy neighbors, ensuring that service degradation does not persist, even during resource contention.

Continue reading on brooker.co.za

#reading-list #pattern #best-practice

🔗 AI and the Ship of Theseus

2026-04-17T13:00:00Z

Because code gets cheaper and cheaper to write, re-implementations are becoming more common. This post highlights considerations regarding copyright implications when AI-generated code is involved, especially concerning licensing like GPL versus more permissive options.

The emergence of AI-generated code may lead to many software projects reappearing under different licenses, raising questions about copyrights and authorship. This situation may ignite renewed debates around copyleft and permissive licenses, with advocates stressing the value of open sharing against those who prioritize licensing enforcement.

Continue reading on lucumr.pocoo.org

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

🔗 AI code review tools: what works, what doesn't, and how to set it up

2026-04-17T08:00:00Z

AI code review tools excel at catching mechanical issues like security patterns, formatting violations, test coverage gaps, and code smells that humans miss when fatigued. However, they consistently fail at architectural decisions, business logic validation, and recognizing when correct code represents the wrong approach.

The practical setup involves choosing a tool based on infrastructure constraints, configuring it to reduce noise, and establishing a workflow where AI reviews first to handle surface-level checks. Human reviewers then focus on depth—architecture, business logic, and strategic fit—making reviews faster and more focused rather than replacing human judgment entirely.

Continue reading on madewithlove.com

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