🐥 YellowDuck.be

🔗 Writing code that feels native to Laravel

2026-06-09T17:00:00Z

Certain patterns emerge when working with Laravel that can greatly enhance your application code. The framework’s emphasis on convention over configuration creates a consistent experience; features integrate seamlessly due to familiar methods and behaviors.

The article illustrates how Laravel's facades act as static proxies, resolving classes from the container, especially in testing environments. By adopting a similar approach in your own service classes, developers can enhance testability and promote consistency.

This extends to defining methods like handle for action classes, making them predictable and easy to work with.

Ultimately, following Laravel's established conventions helps ensure that application code blends harmoniously with the framework, reducing complexity for future developers who interact with it.

Continue reading on ryangjchandler.co.uk

#reading-list #pattern #laravel #php #best-practice #testing

🔗 The hidden danger of shipping fast

2026-06-09T13:00:00Z

Is it possible to ship too much – or too fast? Cleo highlights the risks that come with high product velocity, particularly when it surpasses user adoption. Many companies rush to deliver features, but this can result in a backlog of user unawareness and ultimately leads to reduced quality and increased time-to-value.

Cleo emphasizes that the true bottleneck isn't the speed of production, but rather the limited user attention. Effective strategies include treating user attention as a scarce resource, building discovery directly within the product, and measuring learning outcomes, not just feature usage.

Fast shipping can be beneficial, but only if it aligns with user adoption. Success lies in selective marketing and creating awareness that matches the pace of development.

Continue reading on newsletter.posthog.com

#reading-list #development #best-practice

🔗 Watching for file changes on macOS

2026-06-09T08:00:00Z

When working on a website, live reload can greatly enhance productivity. This article outlines a method to implement this feature on macOS using the File System Events API. The author, who transitioned from using Jekyll to a custom static site generator, explains how to build a Swift script that listens for file system changes without relying on third-party libraries.

The focus is on optimizing performance, with the final implementation detecting file changes within milliseconds, compared to slower polling methods. Step-by-step details, including handling cleanup and the event stream lifecycle, provide a comprehensive guide for developers looking to implement similar live reload capabilities in their projects. This approach not only showcases the technical implementation but also touches on practical performance considerations.

Continue reading on alexwlchan.net

#reading-list #development #tools #mac

🐥 The silent saboteur: how --quiet can break your Laravel command sequences

2026-06-08T17:00:00Z

When you chain multiple Artisan commands together in Laravel, there's a subtle trap waiting for you — one that's easy to miss because the commands still run, they just stop talking.

The setup

A common pattern in Laravel applications is a "meta-command" that runs a sequence of other commands in order. Think of a nightly job runner:


public function handle(): int
{
    $commandsToRun = [
        SomeCommand::class        => [],
        AnotherCommand::class     => [],
        DatabasePruneCommand::class => ['--quiet' => true],
        MoreCommands::class       => [],
        FinalCommand::class       => [],
    ];

    foreach ($commandsToRun as $commandToRun => $parameters) {
        $this->output->title($commandToRun);
        Artisan::call($commandToRun, $parameters, $this->output);
    }

    return self::SUCCESS;
}

You pass $this->output into each Artisan::call so the sub-command's output flows through to the console. Clean and straightforward.

The problem

One of your commands — say, a prune command — is noisy by default. You don't want its output cluttering the logs, so you pass '--quiet' => true. The title still appears, the command runs, everything looks fine.

Then you notice something odd: the commands after that quiet one stop printing their titles. The log files confirm they're running, but the console goes dark after that one --quiet call.

Why it happens

When Laravel processes the --quiet flag on a command, it calls:


$output->setVerbosity(OutputInterface::VERBOSITY_QUIET);

The key word is on the output object you passed in. Because you shared $this->output across all Artisan::call invocations, that single setVerbosity call mutates the object in place. Every subsequent command — and every title(), info(), or line() call — now runs against a quietly-configured output. They're suppressed silently, with no error.

The commands still execute; they just can't speak.

The fix

Capture the verbosity before each call and restore it immediately after:


foreach ($commandsToRun as $commandToRun => $parameters) {
    $this->output->title($commandToRun);

    $verbosity = $this->output->getVerbosity();
    Artisan::call($commandToRun, $parameters, $this->output);
    $this->output->setVerbosity($verbosity);
}

Two lines. The sub-command can do whatever it likes to the output during its run; your sequence always gets a clean slate for the next iteration.

The lesson

Shared mutable objects are the classic source of action-at-a-distance bugs. The output object here is a perfect example: you pass it in expecting read-like behaviour (writing to the terminal), but the callee has full write access to its configuration too.

A few takeaways:

Passing an object "for output" also grants mutation rights. Laravel's OutputStyle is stateful — verbosity, decorations, and more can be changed by anyone holding a reference.
Commands that still run aren't necessarily commands that are working correctly. Silent output suppression looks identical to "nothing went wrong" if you're only checking exit codes or log files.
Test the observable side effects, not just execution. A test that asserts title() is called N times would have caught this immediately; a test that only checks Artisan::call was invoked N times would not.

Bonus: write the test first

If you'd written this test before the bug appeared, you'd have been protected from day one:


public function it_restores_verbosity_so_quiet_commands_do_not_suppress_subsequent_output(): void
{
    // Simulate a sub-command that sets quiet mode
    Artisan::shouldReceive('call')
        ->twice()
        ->andReturnUsing(function () use ($output): int {
            $output->setVerbosity(OutputInterface::VERBOSITY_QUIET);
            return 0;
        });

    // Both titles must still appear
    $output->expects($this->exactly(2))->method('title');

    $this->subject->runSequenceOfCommands($command, [
        'first:command'  => [],
        'second:command' => [],
    ]);
}

Shared mutable state is everywhere in framework code. A little defensive save-and-restore goes a long way.

#development #laravel #best-practice

🔗 Chasing a Phoenix LiveView long poll reload issue

2026-06-08T13:00:00Z

The issue with the reload loop in a Phoenix 1.7 LiveView app stemmed from the requirement for long poll distribution. Users faced a frustrating loop where pages reloaded every seven seconds, showing a "Something went wrong! Hang in there while we get back on track" message. Despite staging environments working fine, the production setup running on AWS ECS behind Cloudflare illustrated a stark contrast due to server distribution.

Debugging revealed a critical difference where production returned a 410 status code related to session management—highlighting the necessity for all Phoenix nodes to connect for long poll fallback to function. Dan Schultzer meticulously details how enabling distribution resolved this issue and emphasizes the importance of this setup for ensuring proper PubSub messaging across all application nodes. A must-read for developers facing similar challenges in Phoenix apps.

Continue reading on danschultzer.com

#reading-list #phoenix #devops

🔗 Moving away from Tailwind, and learning to structure my CSS

2026-06-08T08:00:00Z

Moving from Tailwind to a more semantic HTML and vanilla CSS approach can be liberating. The author reflects on their journey of migrating several sites away from Tailwind after years of reliance on it. They found newfound joy in structuring CSS and learned to impose systems that simplify the management of layouts, fonts, colors, and components. By adopting a component-based approach, reminiscent of modern frameworks, they established clearer boundaries in their styles.

Emphasizing methodologies such as using CSS variables for colors and font sizes, they also explored responsive design through CSS Grid, minimizing the need for breakpoints. The motivations for this shift stem from a desire to embrace the depth of CSS while simultaneously moving away from Tailwind’s increasing dependency on build systems.

This article highlights the author's evolving understanding of CSS and the excitement of rediscovered creativity in styling.

Continue reading on jvns.ca

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

🔗 How I moved my digital stack to Europe

2026-06-07T17:00:00Z

The urgency behind digital sovereignty often gets overlooked. However, this article provides a compelling case for why moving to European cloud services can not only provide better control over data but also align with personal values that prioritize privacy and autonomy.

The author outlines their migration process, starting with the transition from Google Analytics to Matomo, ensuring GDPR compliance without sacrificing functionality. Other shifts included moving from Google Workspace to Proton Mail, offering enhanced privacy protections, and switching from AWS S3 to Scaleway for more localized object storage.

With each change, considerations for usability and long-term implications were meticulously documented, shedding light on the challenges and rewards of such a transformation.

Continue reading on monokai.com

#reading-list #devops

🔗 The myth of never giving up

2026-06-07T13:00:00Z

There’s a myth in the startup world suggesting that relentless perseverance guarantees success. However, Marc Randolph challenges this notion by distinguishing between productive persistence and stubbornness. He argues that while persistence is vital, it’s crucial to recognize when efforts become futile. Randolph emphasizes two warning signs: when enthusiasm wanes and when all avenues have been exhausted without new insights.

He shares a personal anecdote from his time at Netflix, illustrating how genuine curiosity can drive productive work. Ultimately, he stresses that every hour invested in a lost cause could hinder new opportunities. Balancing persistence and recognizing the right moments to pivot is pivotal for entrepreneurs. The key lies in being honest about one's enthusiasm and whether real learning and progress are occurring—allowing gut feelings to guide decisions.

Continue reading on marcrandolph.substack.com

#reading-list #best-practice

🔗 What’s gone wrong at GitHub?

2026-06-07T08:00:00Z

Reliability issues are driving users away in their droves. GitHub’s uptime has plummeted, with 257 logged incidents in just a year. In a shocking turn, the rapid scaling of AI workflows overwhelmed the platform, leading to significant outages, notably in the CI/CD system, Actions. This instability has led prominent users, such as the maintainers of the Zig programming language and HashiCorp co-founder Mitchell Hashimoto, to migrate away, citing unreliability and a deteriorating engineering culture.

GitHub’s CTO acknowledged that the platform wasn’t designed for the current scale demanded, and the integration of Copilot has only exacerbated the situation. As patience wanes among users, GitHub is now focused on ‘availability first’ in an attempt to regain trust amidst mounting pressure for better performance and reliability. The article raises critical questions about the future of GitHub and its role as a cornerstone of developer collaboration.

Continue reading on leaddev.com

#reading-list #ai #devops #github #announcement

🐥 How to check how much memory a systemd unit is actually using

2026-06-06T17:00:00Z

When investigating memory usage on a Linux server, it's common to look at processes using tools such as top, htop, or ps. However, when applications are managed by systemd, it is often more useful to inspect memory usage at the service level rather than at the individual process level.

This is especially important for services that spawn multiple worker processes.

Using systemctl

The easiest way to see the memory usage of a systemd unit is:

systemctl status my-service.service

Example output:

Memory: 423.1M
CPU: 12min 34.567s

This value represents the total memory usage of the service's cgroup, including all child processes managed by the unit.

Using systemctl show

For scripting and automation, use:

systemctl show my-service.service --property=MemoryCurrent

Example:

MemoryCurrent=443662336

The value is returned in bytes.

To convert it to megabytes:

systemctl show my-service.service --property=MemoryCurrent --value \
    | awk '{ printf "%.2f MB\n", $1 / 1024 / 1024 }'

Inspecting the cgroup directly

Systemd tracks resource usage through Linux cgroups.

You can inspect the memory consumption directly:

cat /sys/fs/cgroup/system.slice/my-service.service/memory.current

Or locate the cgroup first:

systemctl show my-service.service --property=ControlGroup

Example:

ControlGroup=/system.slice/my-service.service

Then inspect the corresponding cgroup files.

Finding the processes behind a service

To see which processes belong to a unit:

systemctl status my-service.service

systemctl show my-service.service --property=MainPID

You can then inspect individual processes:

ps -o pid,rss,vsz,cmd -p <PID>

Keep in mind that summing RSS values from multiple processes can overestimate actual memory usage because shared memory pages may be counted multiple times.

Monitoring memory usage over time

For live monitoring:

watch -n 1 \
    'systemctl show my-service.service --property=MemoryCurrent --value'

Or use:

systemd-cgtop

This tool displays CPU, memory, and I/O usage per cgroup and is often the most convenient way to identify memory-hungry services on a system.

Configuring memory limits

Systemd can also enforce memory limits.

Example:

[Service]
MemoryMax=1G

After updating the unit file:

sudo systemctl daemon-reload
sudo systemctl restart my-service.service

To verify the configured limit:

systemctl show my-service.service --property=MemoryMax

Conclusion

For services managed by systemd, MemoryCurrent is usually the most accurate representation of how much memory the service is actually consuming. Unlike process-level tools, it accounts for the entire cgroup, making it ideal for monitoring applications that use worker pools, background jobs, or multiple child processes.

Useful commands to remember:

systemctl status my-service.service
systemctl show my-service.service --property=MemoryCurrent
systemd-cgtop

These provide a much clearer picture of service-level memory usage than inspecting individual processes alone.

#best-practice #linux #sysadmin

🔗 How Claude Code works in large codebases: Best practices and where to start

2026-06-06T13:00:00Z

How does Claude Code thrive in the chaos of large codebases? In an article outlining best practices for deploying Claude Code at enterprise scale, the focus is on efficient navigation, effective harness setup, and contextual awareness. Claude Code manages codebases with millions of lines and varying architectures without needing a centralized index, directly accessing live code.

It emphasizes the importance of contextual setup using CLAUDE.md files, which inform Claude’s operations. Efficient integration of hooks, skills, and plugins enhances its capabilities. This setup avoids common mistakes such as overloading context or failing to scope tools effectively. The detailed patterns and structures presented help organizations maximize Claude Code’s performance in their unique environments, ensuring cohesive and scalable workflows.

Continue reading on claude.com

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

🔗 What if the browser was the server?

2026-06-06T08:00:00Z

The article argues against the traditional SaaS model by suggesting that browsers could effectively serve as their own backends. It highlights how modern SaaS often merely acts as a middleman between users and databases, creating unnecessary delays through network communication.

With advancements like WebAssembly (WASM) and the Origin Private File System (OPFS), developers can deploy fully functional backends that operate directly in users' browsers. The article includes a proof of concept: a simple time tracker built using Go and SQLite, which utilizes OPFS for file storage.

It emphasizes that this approach isn't suitable for applications requiring real-time collaboration, but it does open up new possibilities for many other applications that depend solely on personal data management. The concept could shift how software is distributed, challenging the prevailing assumption that all data must be stored on remote servers.

Continue reading on arthurcornil.com

#reading-list #golang #development #frontend #sqlite

🔗 Using daisyUI means less LLM cost and faster UI generation

2026-06-05T17:00:00Z

If AI is writing the code, does it still matter if we use an efficient component library?

daisyUI significantly reduces token costs and accelerates UI generation by streamlining code. By minimizing verbosity, daisyUI allows for just one class name instead of a long list of utility classes. This not only cuts down on the amount of code LLMs need to read and interpret but also speeds up development.

For instance, a project using Tailwind + daisyUI generates approximately 79% less HTML compared to Tailwind alone, ultimately saving millions of tokens in AI workflows. These savings can dramatically affect project efficiency, making daisyUI a vital choice for developers relying on AI for UI creation.

Continue reading on daisyui.com

#reading-list #frontend #css #ai

🔗 34 days in an Elixir tunnel to refactor my SaaS without a rewrite

2026-06-05T13:00:00Z

Alzo, an Elixir SaaS for architecture firms, faced growth challenges due to its original architecture. Lucas Sifoni spent 34 days refactoring Alzo into a clustered multi-tenant application without a complete rewrite. He removed bottlenecks in the architecture, including eliminating the message broker, and adopted a new model where each tenant receives its own PostgreSQL schema

This approach allowed for easier migrations and tenant management, although it introduced complexity in handling shared data. Sifoni utilized explicit scope passing for tenant data management and enlisted the aid of LLMs to handle numerous compilation errors. He updated the hot-code loading process to accommodate clustering and ensured the system remained efficient during upgrades.

The effort proved worthwhile, enabling the company to grow without losing its iterative development advantages.

Continue reading on lucassifoni.info

#reading-list #best-practice #ai #elixir #postgresql #devops

🔗 Learnings from 100K lines of Rust with AI

2026-06-05T08:00:00Z

What can be achieved with 100,000 lines of Rust and AI? Cheng Huang shares insights from building a modern multi-Paxos consensus engine that outperforms Azure's original Replicated State Library. In just six weeks, he not only implemented all features of the library but also enhanced performance from 23,000 operations per second to 300,000.

His workflow optimized AI coding agents like Claude Code and Codex, which played crucial roles in ensuring correctness through AI-driven code contracts and testing. Huang also redefined his development process with a lightweight spec-driven approach and aggressive performance optimization strategies, uncovering insights that dramatically improved throughput.

With ambitions to further enhance AI-assisted coding, he believes that automating contract workflows and optimizing performance tuning could reshape the future of software development. This article unpacks the methodology and lessons learned, offering a glimpse into the potential of AI in programming.

Continue reading on zfhuang99.github.io

#reading-list #rust #development #ai #testing

🐥 Fixing PHPUnit 13 with*() without expects() deprecations in Laravel tests

2026-06-04T17:00:00Z

After upgrading to PHPUnit 13, you may run into this deprecation warning in Laravel test suites:

Using with*() without expects() is deprecated and will no longer be possible in PHPUnit 14.

At first sight, the code often already looks correct:


$mock->expects($this->once())
    ->method('runSequenceOfCommands')
    ->with([...]);

So what is actually causing the warning?

The real issue

In many Laravel applications, the problem comes from using Laravel’s createPartialMock() helper together with newer PHPUnit versions.

Example:


$class = $this->createPartialMock(
    NightlyCommand::class,
    ['runSequenceOfCommands']
);

While this worked fine in older PHPUnit versions, PHPUnit 13 tightened internal mock expectation handling and now emits deprecation warnings in some cases when using Laravel’s wrapper helpers.

The fix

Instead of createPartialMock(), use PHPUnit’s native mock builder API.

Replace this:


$class = $this->createPartialMock(
    NightlyCommand::class,
    ['runSequenceOfCommands']
);

With this:


$class = $this->getMockBuilder(NightlyCommand::class)
    ->onlyMethods(['runSequenceOfCommands'])
    ->getMock();

And for multiple mocked methods:


$class = $this->getMockBuilder(NightlyCommand::class)
    ->onlyMethods([
        'runSequenceOfCommands',
        'confirm',
    ])
    ->getMock();

Why this works

getMockBuilder() uses PHPUnit’s modern native mock API directly, avoiding the legacy compatibility layer behind Laravel’s partial mock helpers.

This makes your tests:

compatible with PHPUnit 13
future-proof for PHPUnit 14
less dependent on framework-specific mock wrappers

Final result

Your expectations can stay exactly the same:


$class->expects($this->once())
    ->method('runSequenceOfCommands')
    ->with(
        $this->isInstanceOf(NightlyCommand::class),
        [
            // expected commands
        ]
    );

But by switching to getMockBuilder(), the deprecation warning disappears cleanly.

#laravel #php #best-practice #testing

🔗 Composable SFTP streams in Elixir

2026-06-04T13:00:00Z

In Elixir, handling large media files over SFTP can lead to memory issues, especially with immense video files. Through lazy enumerables, Elixir allows developers to process streams efficiently without loading everything into memory. The article outlines how to use File.stream!/2 to manage this stream and demonstrates implementing the Collectable protocol for custom SFTP streams. It emphasizes the architectural benefits of this approach, such as improved flexibility and adherence to Elixir conventions. By leveraging the Stream.into/2, the implementation allows seamless integration and file transfers without overloading the process or complicating the existing codebase. This opens up avenues for better handling of file uploads to different destinations, like S3, while maintaining an elegant and functional programming style.

Continue reading on kevinschweikert.de

#reading-list #development #best-practice #elixir

🔗 How I write HTTP clients

2026-06-04T08:00:00Z

How do you build effective HTTP clients? Blain Smith shared his experiences developing HTTP clients for 3rd party APIs, outlining critical patterns he's observed. This includes essential components like composing client options, JSON encoding/decoding in Go, HTTP request signing, and creating convenience methods for easier API interactions.

He highlights a practical example with the Infogram Go client, sharing code snippets for implementing struct tags and handling requests efficiently. Understanding these concepts can significantly boost the quality and testability of your HTTP clients. Smith's article serves as a valuable resource for developers looking to streamline their API interactions and improve their coding practices.

Continue reading on blainsmith.com

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

🔗 Computer use is 45x more expensive than structured APIs

2026-06-03T17:00:00Z

A benchmark study shows that AI agents using computer vision to navigate web interfaces are 45 times more expensive than those using structured APIs, largely due to higher token consumption and performance variance. While vision-based agents are still necessary for third-party software, auto-generating API surfaces for internal tools provides a far more efficient and cost-effective deployment strategy.

Continue reading on reflex.dev

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

🔗 Why developers should – and shouldn’t – use LLMs in our development

2026-06-03T13:00:00Z

Why should I use AI? This pressing question is at the forefront of our evolving software development landscape. In the wake of LLMs like ChatGPT, developers must decide how to harness this technology effectively. While LLMs excel at handling repetitive tasks or producing prototypes quickly, they can compound security risks and tech debt if misused. I found that the clients I work with sometimes desire AI solutions even when they're unnecessary. This muddles our understanding of their actual needs, highlighting the importance of expert insight over flashy trends. I’ve noticed the most significant shifts in our workflow center on using LLMs to free developers from rote tasks, allowing us to focus on creative problem-solving instead. However, caution can't be overlooked: without proper review, LLM-generated code can lead to serious vulnerabilities.

Continue reading on tighten.com

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

🔗 The robots are replacing the packages

2026-06-03T08:00:00Z

The way AI-assisted development is changing how developers handle package installations is striking. Manual coding may have taken time, but with intelligent agents automating the background work, developers can focus on high-level tasks. The article categorizes common scenarios developers face in package decision-making: shared problems where robots excel, complex issues requiring thorough modeling, external dependencies needing ongoing maintenance, and opinionated frameworks shaping project direction. By understanding which problems to delegate to robots versus those that require human oversight, developers make smarter choices. The piece emphasizes a shift from finding solutions to knowing whether one wants to own a particular problem, marking a significant evolution in software development practices.

Robots are taking over package handling, letting us focus on complex problems. Discover the four categories that define when to leverage this AI power.

Continue reading on spatie.be

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

🐥 Why crypto.getRandomValues() matters in JavaScript

2026-06-02T17:00:00Z

Generating random values sounds simple, until you need randomness that is actually secure.

A lot of JavaScript developers reach for Math.random() out of habit. While that works fine for visual effects, games, or non-critical IDs, it should never be used for anything security-sensitive.

That’s where the Web Crypto API comes in.

The problem with `Math.random()`

Math.random() is not cryptographically secure.

Its output is deterministic and predictable enough that an attacker may be able to reproduce or guess generated values under certain conditions.

That makes it unsuitable for:

Session tokens
Password reset links
API keys
CSRF tokens
Encryption keys
Secure identifiers

Example:

const id = Math.random().toString(36).slice(2)

This may look random, but it is not secure.

Using `crypto.getRandomValues()`

Modern browsers provide a secure random number generator through the Web Crypto API.

Example:

const bytes = new Uint8Array(16)

crypto.getRandomValues(bytes)

console.log(bytes)

This fills the typed array with cryptographically secure random bytes provided by the operating system.

Generating a secure random token

A common use case is generating secure tokens or identifiers.

function generateToken(length = 32) {
  const bytes = new Uint8Array(length)

  crypto.getRandomValues(bytes)

  return Array.from(bytes)
    .map(byte => byte.toString(16).padStart(2, "0"))
    .join("")
}

console.log(generateToken())

Example output:

4f8b7d3a1f9e0c8d7a2b6c5d4e3f1a9c

This is significantly safer than using Math.random().

Typed arrays are required

crypto.getRandomValues() only works with integer-based typed arrays.

Supported examples include:

new Uint8Array(32)
new Uint16Array(16)
new Int32Array(8)

This will fail:

crypto.getRandomValues([])

Because regular JavaScript arrays are not supported.

Browser and runtime support

crypto.getRandomValues() is widely supported in modern browsers.

It is also available in runtimes like:

Node.js
Deno
Bun

Example in Node.js:

const bytes = new Uint8Array(16)

crypto.getRandomValues(bytes)

console.log(bytes)

In older Node.js versions, developers typically used:

require("crypto").randomBytes(16)

UUID generation

If your goal is generating UUIDs, modern runtimes also support:

crypto.randomUUID()

Example:

550e8400-e29b-41d4-a716-446655440000

Internally, this also uses cryptographically secure randomness.

Things to remember

Use Math.random() for non-security-related randomness only
Use crypto.getRandomValues() for anything security-sensitive
Prefer crypto.randomUUID() when generating UUIDs
Always generate randomness using the operating system’s secure RNG

For modern JavaScript applications, crypto.getRandomValues() should be the default choice whenever security matters.

#javascript #best-practice #auth

🔗 The language of the boundary

2026-06-02T13:00:00Z

The article discusses the development journey of creating a JSON Schema validator library for Elixir, detailing the complexities encountered when integrating JSON schema validation with Open API Spex. It emphasizes the necessity of validating data at boundaries, where untrusted external data is handled. The author, reflecting on past experiences, distinguishes between validating solely within Elixir and creating a shared understanding through JSON Schema among various programming teams, particularly in relation to Python and TypeScript. In exploring the challenges of maintaining and implementing validation rules effectively, the piece advocates for treating validation rules as data rather than as code, highlighting the importance of schemas as a means of ensuring compatibility and accuracy across different technologies. Ultimately, the author champions JSON Schema as the preferred solution for establishing clear, functional boundaries in application development.

Continue reading on lud.codes

#reading-list #development #best-practice #elixir

🔗 AI agents keep failing. The fix is 40 years old.

2026-06-02T08:00:00Z

AI agents often falter due to hidden dependencies in the code, leading to failures in production environments. This issue stems not from the models themselves but from the tight coupling and mutable states in the codebase that AI agents cannot effectively navigate. As Cyrus Radfar points out, while human developers build mental models over time, AI lacks that context, resulting in complicating hidden states that cause cascading errors. To remedy this, he suggests applying long-established principles of functional programming from the 1980s. By ensuring that all functions are pure, with explicit data flows and minimal side effects, AI agents can operate more reliably in scenarios where codebases contain numerous dependencies. This approach enables agents to modify functions without facing the risk of unintended consequences from hidden global states. The implementation of these principles could significantly enhance AI-driven development practices.

Continue reading on cyrusradfar.com

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

🔗 Claude Code is a build system, not a chatbot

2026-06-01T17:00:00Z

Claude Code redefines the interaction with AI coding by treating it as a build system rather than merely a chatbot. After a year of iteration, the author emphasizes the importance of treating AI like a configurable, layered, and observable engineering system. By moving from passive to active enforcement of coding standards and best practices, projects become less prone to errors, especially when attention drifts. The article explains how to set up automatic checks, the significance of writing standards clearly, and the benefits of using specialized subagents for tasks, plus future-proofing code through systematic hooks. With insights from the author's experiences across various programming languages, this piece serves as a guide to enhance AI-driven development and maintain consistency and quality in coding practices over time.

Continue reading on vinny.dev

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

🐥 YellowDuck.be

🔗 Writing code that feels native to Laravel

🔗 The hidden danger of shipping fast

🔗 Watching for file changes on macOS

🐥 The silent saboteur: how --quiet can break your Laravel command sequences

The setup

The problem

Why it happens

The fix

The lesson

Bonus: write the test first

🔗 Chasing a Phoenix LiveView long poll reload issue

🔗 Moving away from Tailwind, and learning to structure my CSS

🔗 How I moved my digital stack to Europe

🔗 The myth of never giving up

🔗 What’s gone wrong at GitHub?

🐥 How to check how much memory a systemd unit is actually using

Using systemctl

Using systemctl show

Inspecting the cgroup directly

Finding the processes behind a service

Monitoring memory usage over time

Configuring memory limits

Conclusion

🔗 How Claude Code works in large codebases: Best practices and where to start

🔗 What if the browser was the server?

🔗 Using daisyUI means less LLM cost and faster UI generation

🔗 34 days in an Elixir tunnel to refactor my SaaS without a rewrite

🔗 Learnings from 100K lines of Rust with AI

🐥 Fixing PHPUnit 13 with*() without expects() deprecations in Laravel tests

The real issue

The fix

Why this works

Final result

🔗 Composable SFTP streams in Elixir

🔗 How I write HTTP clients

🔗 Computer use is 45x more expensive than structured APIs

🔗 Why developers should – and shouldn’t – use LLMs in our development

🔗 The robots are replacing the packages

🐥 Why crypto.getRandomValues() matters in JavaScript

The problem with Math.random()

Using crypto.getRandomValues()

Generating a secure random token

Typed arrays are required

Browser and runtime support

UUID generation

Things to remember

🔗 The language of the boundary

🔗 AI agents keep failing. The fix is 40 years old.

🔗 Claude Code is a build system, not a chatbot

The problem with `Math.random()`

Using `crypto.getRandomValues()`