🐥 YellowDuck.be

🔗 Build an MCP server with Laravel (and use it to publish this post)

2026-06-23T17:00:00Z

Every MCP server tutorial you'll find is written in Python or TypeScript. If you're a Laravel developer, you've been left out of the conversation — until now. Laravel's official laravel/mcp package lets you build MCP servers that expose your application's functionality directly to AI assistants like Claude. This setup eliminates traditional concerns like REST API design and authentication tokens. In just about 20 minutes, the author created an MCP server to manage this very blog post.

The article dives into the Model Context Protocol (MCP), an open standard that enables AI assistants to perform structured actions with clear inputs and outputs. With Laravel's support for both stdio and HTTP transports, users can effortlessly query, create, update, and publish blog posts, all without navigating a browser. From tools like CreatePostTool to PublishPostTool, each section details simple class implementations, helping developers seamlessly integrate AI interactions with their Laravel applications.

Continue reading on thunk.dev

#reading-list #laravel #php #ai

🔗 Software engineering discipline and posture

2026-06-23T13:00:00Z

There’s something quietly dignified about a clean commit history and well-written documentation. This article by Blain Smith emphasizes that engineering discipline is rooted in respect for teammates. Respect isn't just a thumbs-up emoji; it’s about naming variables wisely and writing comprehensive documentation that doesn’t assume prior knowledge.

Commits serve as ongoing conversations, not merely logs of activity. Each commit message should prioritize clarity, recognizing that it may be read long after its creation. Pull requests are portrayed as invitations for collaboration, requiring context and clarity rather than vague demands. The piece stresses the importance of making improvements every time code is touched, no matter how small. Ultimately, engineering transcends merely shipping features; it’s about enhancing the experience for future developers, thus advocating for a respectful, disciplined approach to software craftsmanship.

Continue reading on blainsmith.com

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

🔗 Pair-programming is a cheat code

2026-06-23T08:00:00Z

Pair-programming is often called a cheat code for developers and businesses alike. It not only accelerates decision-making but also promotes real-time code reviews and knowledge transfer. Instead of enduring lengthy pull-request reviews, pairs can bounce ideas off one another immediately, reducing the risk of expensive changes late in the development cycle.

Additionally, frequently rotating pairs helps prevent knowledge silos, ensuring that no single developer is solely responsible for critical areas of the codebase. This method also serves as an effective teaching tool for junior developers, allowing them to absorb best practices quickly. In a world increasingly influenced by AI, maintaining this collaborative practice becomes crucial for keeping skills and knowledge current.

Overall, the benefits of pair-programming are clear, encouraging teams to embrace it more fully for long-term success.

Continue reading on www.germanvelasco.com

#reading-list #development #pattern #best-practice

🔗 GenServer state management in Elixir: A production order book

2026-06-22T17:00:00Z

One GenServer manages critical aspects of trading like open positions, pending orders, and strategy state in real-time systems. This article highlights the state struct that powers the RealtimeTrader, which functions as a session-scoped process in a trading pipeline. It breaks down the state management into three essential categories: runtime data comprising orders and account balance, collaborator references for dependency management, and operational flags that control system behavior.

The article emphasizes design choices that allow strategies to maintain state effectively and how important features like trading flags can prevent system errors, ensuring trading activities run smoothly. Furthermore, readers gain access to full source code, enabling them to see production-grade implementations directly in action.

Continue reading on seriousalchemy.com

#reading-list #development #pattern #elixir

🔗 Concurrent reads, serialized writes with GenServer and Registry

2026-06-22T13:00:00Z

GenServer is often a beginner's first encounter with Elixir, but common pitfalls can arise, especially concerning data access patterns. This article highlights an issue when using GenServer.call for reading data as it serializes requests, blocking concurrent access and affecting performance, such as the refresh timer for data.

The solution involves utilizing Registry, which allows registering processes and storing data without the complexities of managing ETS lifecycle. By implementing a via tuple, the GenServer can store its state in Registry, enabling concurrent read access. The article provides a practical example with the FXRates module demonstrating how to effectively use Registry to facilitate concurrent reads while still serializing writes. This approach not only optimizes access patterns but simplifies code management as well.

Continue reading on distantprovince.by

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

🔗 The beginning of programming as we’ll know it

2026-06-22T08:00:00Z

In the wake of AI coding assistants like Claude and Codex, many wonder if the role of a computer programmer is coming to an end. While it seems AI can perform tasks in minutes, it is not time to count human programmers out. Currently, human developers are essential for overseeing AI outputs because they infuse wisdom and creativity, which AI lacks.

Although there are many success stories of AI constructing applications from specifications, they often overshadow numerous AI failures that produce unusable code. The reality is that AI-generated code cannot be deemed complete until a human reviews and corrects it. Adopting a healthy skepticism towards AI outputs will help developers maintain quality standards.

As the landscape evolves, those who leverage AI effectively without relinquishing control will likely remain indispensable in their roles. This mantra echoes across all creative professions, reminding us that human oversight is paramount in the face of advancing technology.

Continue reading on bitsplitting.org

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

🔗 Rust vs Go: A hands-on comparison

2026-06-21T17:00:00Z

Oh no, not another 'Is Rust better than Go?' article. Seriously, haven't we all had our fill of these comparisons by now? But before you sigh in exasperation, hear us out!

Many comparisons between Go and Rust emphasize their differences in syntax and the initial learning curve. However, ultimately, what matters is the ease of use for non-trivial projects.

Since we are a platform-as-a-service provider, we think that we can contribute the most by showing you how to build a small web service in both languages. We will use the same task and popular libraries for both languages to compare the solutions side-by-side so that you can make up your own mind and get a feel for what it's like to work in each ecosystem.

So, before you dismiss this as 'just another comparison', give it a read. There might be some details that other comparisons have missed before.

Continue reading on www.shuttle.dev

#reading-list #golang #rust #development

🔗 Reading a 200k-line codebase you didn't write: a field guide

2026-06-21T13:00:00Z

Is it really possible to understand a sprawling 200,000-line codebase that someone else authored? Christoph Beck's article presents a practical guide to tackling inherited code through a systematic approach. Starting without diving directly into the files, Beck emphasizes the importance of first interpreting the project's structure, including the directory tree, dependency manifests, CI configuration, and git history.

By pairing human intuition with coding agents, developers can uncover insights about the codebase's history and current state. The article details how to analyze project components efficiently, looking for clues that highlight the team’s practices and any lurking issues. With quick commands and thoughtful interpretation, readers gain a comprehensive understanding of how a legacy codebase functions before they read a single line of code.

Continue reading on bitcrowd.dev

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

🔗 Claude talk small. Code still big.

2026-06-21T08:00:00Z

AI coding assistants often provide lengthy explanations with every change. But what if they cut down on chatter?

The author shares their experience using the "Caveman" skill, which simplifies AI output to short, effective phrases like "Me fix bug". While this approach saved tokens, the actual savings were less than anticipated.

Most tokens are spent on reading files and generating code, rather than on explanations alone. Despite this, there's merit in the brevity for simple tasks, keeping reviews light-hearted and efficient.

However, for more complex changes, traditional communication is still essential to capture important context.

In conclusion, while the Caveman skill doesn't revolutionize AI coding assistants, it provides a lighter, more amusing way to handle quick tasks.

Continue reading on spatie.be

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

🔗 OAuth 2.0 – device flow explained for engineers, especially for backend engineers

2026-06-20T17:00:00Z

A frustrating login experience with long passwords on devices led to the development of OAuth 2.0 device flow. This flow provides a practical solution for scenarios where typing passwords is unfeasible, such as on smart TVs or IoT devices.

The article details how to implement this flow step-by-step using a command-line interface called mycli. It breaks down how to handle the authorization process effectively, manages polling, and explains the various server responses that developers must anticipate.

With real-world examples of how this flow enhances user experience, the piece serves as a guide for backend engineers to streamline authentication processes for users facing input constraints, ultimately urging developers to implement it in their applications.

Continue reading on stackoverflow.blog

#reading-list #development #http #auth

🔗 Laravel MCP: Getting started

2026-06-20T13:00:00Z

Your AI coding agent writes better code when it has real context about your application.

This article examines the Laravel MCP, which provides a structured way to expose your app’s capabilities to AI clients, like ChatGPT and Claude. Without MCP, AI agents can misinterpret your app's architecture, causing them to guess column names and routes. By utilizing the laravel/mcp package, developers can build an MCP server that allows their applications to interact intelligently with AI.

This starts to shine when integrating with non-technical users, simplifying data access without needing knowledge of APIs or CLI calls. The piece also covers practical steps for setting up an MCP server, tools, resources, prompts, and authentication methods, ensuring that readers can effectively harness AI to interact seamlessly with their Laravel applications.

It drives home the importance of structured integration as development scales, particularly in enterprise environments.

Continue reading on laravel.com

#reading-list #laravel #php #ai

🔗 Credence: Elixir semantic linter

2026-06-20T08:00:00Z

A semantic linter for LLM-generated Elixir code.

Elixir's compiler checks syntax. Credo checks style. Credence checks semantics — it mainly catches patterns that compile and pass tests but are non-idiomatic, inefficient, or ported from Python/JavaScript conventions that don't belong in Elixir.

Continue reading on hex.pm

#reading-list #development #tools #elixir

🔗 The tacit dimension: why your best engineers can't tell you what they know

2026-06-19T17:00:00Z

In today's software development landscape, the tacit knowledge held by experienced engineers is undervalued and often overlooked. This article argues that while explicit knowledge is easily documented and processed by AI, the intuitive insights and patterns recognized by seasoned developers are impossible to articulate or transfer effectively to artificial intelligence.

The piece draws on Michael Polanyi's concept of tacit knowledge to illustrate how many crucial understandings in engineering cannot be reduced to written words. As teams increasingly rely on AI for coding tasks, there's a rising danger of losing this invaluable insight, which could leave future engineers ill-equipped to navigate complex codebases.

The author warns that, without intentional mentorship and collaboration, the next generation could experience a decline in critical thinking and problem-solving skills, making the role of experienced engineers more essential than ever.

Continue reading on cekrem.github.io

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

🔗 AI’s impact on software engineers in 2026: key trends, Part 2

2026-06-19T13:00:00Z

What if AI tools not only boost productivity but also lead to decreased code quality? In this concluding part of the series, Gergely Orosz and Elin Nilsson delve into the findings from over 900 survey responses regarding AI's effects on software engineers by 2026. They reveal that while AI can reduce the time spent on routine tasks, it introduces new challenges like unrealistic expectations and quality issues.

Many companies struggle with large-scale adoption, finding that effective AI use depends heavily on existing engineering practices. Engineers report a decline in codebase quality, with more bugs sneaking into projects and less experienced programmers grappling with AI-generated code. The piece emphasizes the need for robust guidelines and highlights the complex influence of AI on collaboration, highlighting varying impacts based on individual adaptability and team culture.

Continue reading on newsletter.pragmaticengineer.com

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

🔗 High performance Git

2026-06-19T08:00:00Z

Git serves multiple roles beyond just version control; it operates as a content-addressed database, a filesystem cache, and more. This article dives into the different layers of Git, discussing the performance implications of objects, refs, the index, and history traversal. It covers advanced topics like packfiles, maintenance, sparse working trees, and the nuances of partial cloning.

Written specifically for engineers—particularly those in build, CI, and developer experience roles—the content highlights the importance of maintaining speed and efficiency as repositories grow in size and complexity. It offers insights into diagnosis, configuration, and recovery, making it a valuable resource for anyone managing Git at scale.

Continue reading on gitperf.com

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

🔗 Make friends with your AI assistant

2026-06-18T13:00:00Z

Could your AI assistant be causing more chaos than compliance? This article emphasizes the importance of structured workflows and clear rules when working with AI. It illustrates how utilizing start and stop words can prevent careless commits and untested code pushes. Furthermore, it stresses that providing clean code examples is essential for quality outputs from the assistant.

The author highlights a systematic approach to task management, urging readers to break down large tasks to avoid confusion. With emphasis on the art of feedback, the piece offers practical advice on how to effectively communicate with the assistant, enhancing productivity while minimizing errors. The article provides a detailed checklist for AI assistance that every developer should consider for improved results.

Continue reading on rocket-science.ru

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

🔗 Before GitHub

2026-06-18T08:00:00Z

GitHub was not the first home for Open Source software; SourceForge was. Before it, Armin Ronacher had his own Trac installation with Subversion repositories, tickets, and documentation. GitHub became essential, shaping a significant part of his Open Source identity and fostering countless professional relationships.

However, he expresses disappointment in GitHub's current trajectory and laments the loss of community presence that defined the platform. He recalls a time when dependencies had depth and context, contrasting the current scenario where micro-dependencies proliferate with less regard for the maintainers behind them. The article warns about GitHub's decline and the implications for the Open Source community, urging for a structured archiving solution to preserve essential projects and their histories.

Continue reading on lucumr.pocoo.org

#reading-list #development #github #git

🔗 Utilizing Claude skills in client projects

2026-06-17T17:00:00Z

Working on a project for Ticketmatic unveiled a repetitive challenge: integrating with their API using the Saloon library. Despite Artisan commands like php artisan saloon:response, developers still faced tedious work creating DTOs and manually wiring everything. By leveraging Claude Skills, the process transformed dramatically.

Claude generates request files, fixes namespaces, and even creates DTOs based on provided specifications. Although it handles 90% correctly, some review remains necessary. Beyond request generation, skills streamline tasks like creating Livewire components, ensuring ease and consistency in the codebase. This automation reduces mistakes and frees developers to focus on more critical aspects of their work.

Continue reading on spatie.be

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

🔗 Symptoms of bad software design

2026-06-17T13:00:00Z

What are the telltale signs that software design has gone wrong? Marcos F. Lobo identifies four crucial symptoms: rigidity, fragility, immobility, and viscosity. Rigidity surfaces when a change triggers unexpected complications across modules, often due to excessive coupling. Fragility appears when one fix causes multiple issues elsewhere.

Immobility is evident when code is so entangled it's easier to rewrite than reuse. Viscosity represents the tendency to opt for quick, dirty solutions instead of adhering to best practices. Each symptom carries a solution—like employing the Strategy Pattern to combat rigidity or using Clean Architecture to ensure code reusability. Lobo emphasizes that identifying these design flaws paves the way for effective refactoring and better software practices.

Continue reading on newsletter.optimistengineer.com

#reading-list #development #pattern #best-practice

🔗 Why senior developers fail to communicate their expertise

2026-06-17T08:00:00Z

What happens when senior developers and the rest of the business struggle to understand each other? Tuhin Nair delves into a communication gap that arises from differing priorities: senior developers focus on managing complexity, while business teams prioritize speed and uncertainty reduction. Senior developers often express their concerns regarding system stability and complexity, but this doesn’t resonate with non-developers who are driven by a need for rapid market feedback.

Nair argues that effective communication hinges on rephrasing technical solutions to meet business needs. By using phrases like 'Can we try something quicker?', developers can bridge the gap between maintaining stable systems and meeting the business’s urgency to reduce uncertainty. AI agents may promise to streamline tasks, but they lack the responsibility that seasoned developers hold.

This article is a call to rethink how senior developers articulate their value amid the push for agility in software development.

Continue reading on nair.sh

#reading-list #development #best-practice

🔗 Lies I was told about collaborative editing, part 2: Why we don't use Yjs

2026-06-16T13:00:00Z

The common belief that CRDTs like Yjs are essential for seamless collaborative editing faces scrutiny in this article. It argues that the algorithmic complexity and architectural choices behind Yjs compromise performance and reliability. By highlighting serious issues encountered when implementing Yjs—including document corruption and high latency—the author recommends a simpler alternative that meets necessary editing capabilities with far fewer complications.

The article explains a lightweight solution that leverages the prosemirror-collab library, achieving required functionality with just 40 lines of code. This solution avoids the pitfalls seen in Yjs, such as performing excessive document re-creation on every keystroke, and emphasizes the importance of a more straightforward approach that could significantly improve user experience with collaborative editing.

Continue reading on www.moment.dev

#reading-list #javascript #development #best-practice

🔗 Lies I was told about collaborative editing, part 1: algorithms for offline editing

2026-06-16T08:00:00Z

In an era where collaborative editing tools are becoming integral to workflows, some popular algorithms promise effective solutions for both online and offline editing. However, as evaluated in Moment's development blog, many of these algorithms, including CRDTs and OT, result in unintuitive outcomes that users often perceive as data corruption. Out of numerous tests on these algorithms, about 20-30% resulted in conflicts that left documents in states no user would accept.

The piece argues for a reframing of collaborative editing as a UI/UX challenge rather than solely an algorithmic one. With advancements in approach, the vision of improved offline editing experiences may not be far-fetched, especially as researchers like Ink & Switch explore the intersection of algorithms and user interface design.

Continue reading on www.moment.dev

#reading-list #frontend #best-practice #ai

🔗 Piper: Laravel-style array and string helpers for PHP's pipe operator

2026-06-15T17:00:00Z

PHP 8.5's pipe operator enables a seamless flow of data between functions, yet built-in functions and Laravel's classes weren't designed for it. Piper bridges that gap by transforming Laravel's collection and string methods into standalone functions specifically tailored for use with the pipe operator.

The article demonstrates how Piper operates directly on native arrays and strings without needing any wrapper. Functions are curried for easy integration, meaning you can chain array and string transformations fluidly. With its familiar API mirroring Laravel's, developers can easily adopt Piper to streamline their data manipulations in PHP.

It emphasizes that you can mix operations on arrays and strings in a single pipeline, creating a natural and efficient coding style.

Continue reading on laravel-news.com

#reading-list #pattern #laravel #php

🔗 How LLMs interpret websites: guide to AI visibility

2026-06-15T13:00:00Z

How do LLMs interpret the structure of websites? This article from WP Engine delves into how large language models analyze web content to enhance AI visibility. It highlights the significance of clear website architecture and structured data in making content more interpretable to AI.

By optimizing these elements, businesses can improve their online presence and maximize their reach through AI-driven tools. This guide serves as a valuable resource for web developers and marketers looking to harness the power of LLMs in their SEO strategies.

Continue reading on wpengine.com

#reading-list #frontend #best-practice #ai

🔗 Django LiveView vs Phoenix LiveView: a real benchmark

2026-06-15T08:00:00Z

How does Django LiveView stack up against Phoenix LiveView in real-world scenarios? In a recent benchmark, identical alert dashboards were built in both frameworks to measure performance under realistic conditions. The tests showed that both frameworks performed similarly, with around 22 ms for mutations and 7 ms for search in most scenarios.

However, the stark differences emerged in payload sizes and scalability. With larger lists, Django LiveView significantly increased its data transfer, sending more bytes per interaction than Phoenix. Conversely, as the number of concurrent users increased, Phoenix exhibited better scaling capabilities. While Django LiveView allows more explicit control over updates, the inherent advantages of Phoenix's design can lead to lower latency under load. Overall, they are comparable, but for heavy payloads and concurrency, Phoenix may have the edge.

Continue reading on en.andros.dev

#reading-list #development #django #phoenix