Hasty Briefsbeta

All tags

#software development

297 stories total

Bilingual

Choose Boring Technology, Revisited
9 months ago
- The article revisits the 'Choose Boring Technology' philosophy, emphasizing the importance of using well-understood, reliable technologies for solving problems.
- Dan McKinley's argument about limited 'innovation tokens' is highlighted, advocating for strategic use of established technologies over unproven ones.
- The advent of AI coding tools introduces new challenges, as they can generate plausible but potentially flawed code for unfamiliar technologies.
- Using AI with unfamiliar technologies multiplies unknowns, making it hard to verify the correctness or appropriateness of the generated code.
- AI tools are most effective when used with technologies the developer already understands, allowing for accurate review and fact-checking of generated code.
- Practical guidelines include evaluating whether you can review AI-generated code for a new technology before adopting it and resisting the temptation to take on multiple new technologies simultaneously.
- The article warns against the false confidence that AI-generated code can instill, as problematic code may look professional but contain subtle issues.
- The core advice remains: use familiar technologies for problem-solving and limit learning new technologies to one at a time, ensuring deep understanding.
Code with LLMs and a Plan
9 months ago
- Working with state-of-the-art coding agents like Claude Code and sharing experiences.
- Key process for coding with LLM agents: create PLAN.md, refine, implement, review, and repeat.
- Benefits of refining PLAN.md: improves requirements and implementation specificity.
- Different tools used for planning: Gemini for large codebases, Claude Desktop for token efficiency.
- Real-world example: transforming ClickFunnels' public API into an MCP server with LLMs.
- Initial prompt refinement led to a detailed PLAN.md for creating MCP server tools.
- Final process involved LLM extending PLAN.md based on existing tested code and prompts.
- Upcoming topics: parallelizing the process and discussions in Rails Builders groups.
- Resources for learning: 'Vibe Coding' book, Babysitting Agents podcast, Claude Code videos.
- Reflection on rapid changes in AI coding since early documented steps in March 2025.
Fingine: Thoughts on Side Projects and Financial Simulation
9 months ago
- The author aims to retire early (around 55) and take jobs without financial consideration beforehand.
- They use the coast FIRE calculator but find it insufficient, exploring alternatives like ProjectionLab.
- Previously attempted to build 'Fingine', a financial simulation engine, but faced challenges due to lack of finance knowledge and unfamiliarity with Rust.
- Plans to revive Fingine with revised goals: focus on Canadian financial rules, allow custom code for tax credits/deductions, and support Monte Carlo simulations.
- Non-goals include not tailoring to others' financial situations, not focusing on adoption, and not prioritizing performance beyond personal needs.
- Considering Elixir for the project, planning to learn it through books and exercises, and conceptualizing simulations as matrix manipulations.
- Lists financial primitives like accounts, liabilities, income/expense events, and tax systems, suggesting matrix representation for account values and events.
- Mentions the need to learn double-entry accounting (hledger) and further refine the matrix approach for financial simulations.
How I use Claude Code to implement new features in an existing complex codebase
9 months ago
- The article provides a comprehensive guide on using Claude Code, an AI coding tool, for implementing new features in complex codebases.
- It emphasizes the importance of maintaining clean, production-grade code and reducing bugs introduced by AI.
- The guide includes a detailed CLAUDE.md file with coding rules and best practices for implementation, testing, database handling, and code organization.
- Key practices include following Test-Driven Development (TDD), using branded types for IDs, and preferring simple, testable functions.
- Testing best practices highlight the importance of parameterized inputs, strong assertions, and testing edge cases.
- The article outlines a structured AI coding process involving planning, coding, reviewing, and committing changes with specific shortcuts like qnew, qplan, qcode, qcheck, and qgit.
- It warns about the limitations of AI tools in 2025, stressing the need for active oversight to avoid technical debt and suboptimal solutions.
- The guide concludes with resources for further learning and support in AI coding and business scaling.
How we enforce .NET coding standards to improve productivity
9 months ago
- Organizations aim to optimize their Software Development Life Cycle (SDLC) for faster delivery and better quality.
- Workleap analyzed their SDLC to reduce friction and improve developer efficiency without compromising quality.
- Identified inconsistencies in code style, quality, and performance across multiple .NET solutions and C# projects.
- Found that code style issues in pull requests negatively impacted cycle time and developer relationships.
- Discovered build-time warnings and MSBuild-related issues, such as disabled nullable reference types and minimal Roslyn analysis levels.
- Developed a reusable .NET coding standards NuGet package to enforce code style, quality, and performance standards.
- Configured over 800 Roslyn analysis rules and MSBuild properties for consistent, performant builds.
- Enabled automatic code fixes and ensured minimal build duration impact.
- Adopted a 'positive shaming' approach to encourage adoption, resulting in widespread migration across projects.
- Benefits include reduced code review time, improved code quality, and faster builds.
- The .NET coding standards package is open source and available on GitHub and NuGet.org.
Rust, Python, and TypeScript: the new trifecta
9 months ago
- Rust, Python, and TypeScript are predicted to become dominant languages due to AI-driven shifts in programming paradigms.
- Idea-oriented programming emphasizes focusing on project ideas, delegating implementation details to AI tools.
- Rust is favored for system software and efficiency, Python for its mathematical libraries, and TypeScript for web applications.
- Advanced type systems in these languages help manage ambiguity and errors, especially important when working with AI.
- Ecosystems and package managers (like cargo, npm, and uv) are crucial for leveraging libraries efficiently with AI assistance.
- Error messages and guidance in languages like Rust are vital for AI tools to correct mistakes and improve code quality.
- Idea-oriented programming makes high-level design and architecture more accessible, similar to the role of a Principal Engineer.
- The shift to AI-assisted coding changes how engineers approach language choice, focusing more on libraries and performance needs.
- While AI reduces some coding tedium, it introduces new challenges in teaching judgment and maintaining a flow state in programming.
GitHub CEO delivers stark message to developers: Embrace AI or get out
9 months ago
- GitHub CEO Thomas Dohmke warns developers to embrace AI or leave the profession.
- AI is transforming software development from coding to managing and verifying AI outputs.
- Developers must adapt to AI tools to remain relevant as automation advances.
- Interviews with 22 developers show AI is already a present necessity in workflows.
- Developers' roles are shifting from writing code to architecting and auditing AI-generated code.
- Early adopters of AI tools gain leverage, not redundancy, in their careers.
- AI is expected to automate up to 90% of code writing within two to five years.
- Future developer skills will include system design, AI fluency, delegation, and quality assurance.
- Dohmke acknowledges that not all developers will want to adapt to these changes.
OOP is not Design Patterns
9 months ago
- OOP concepts like inheritance and polymorphism are building blocks, not code structuring methods.
- Design patterns help structure code and create a common language with stakeholders.
- Not all OO concepts are necessary; reusable and maintainable code can be built without them (e.g., Go lacks inheritance).
- Junior developers should leverage existing patterns instead of reinventing solutions.
- Senior engineers should guide juniors to avoid redundant discoveries.
- Design patterns have criticisms and should not be forced as defaults; their use is an art.
- Mastering design patterns requires repetition and experience to recognize when to apply them.
- Overcoming the initial learning threshold is a key challenge in adopting design patterns.
81% of people more wary of dependencies due to AI
9 months ago
- 81.63% of respondents are more wary of software dependencies due to AI usage.
- AI tooling changes the assumption that dependencies are written by knowledgeable developers.
- AI code helpers may add unnecessary dependencies without proper validation.
- Maintainers adopting AI-first approaches could lead to more unchecked code changes.
- Review fatigue from rapid AI-generated changes may increase dependency risks.
- Teams should reduce dependency footprints and review existing dependencies regularly.
- Pre-approved dependencies and stricter approval processes can mitigate risks.
- Improving test suites can help catch errors caused by dependencies.
- The poll had 49 votes, indicating a small but strong trend toward wariness.
- Future polls should separate 'The Same' and 'Don’t Care' options for clarity.
UI vs. API. vs. UAI
9 months ago
- The text discusses the evolution of interfaces from UI (User Interface) for humans to API (Application Programmable Interface) for applications, and now UAI (User Agent Interface) for agents like LLMs.
- It emphasizes the importance of designing features to be accessible and legible across all three interfaces (UI, API, UAI) without degrading any one of them.
- Highlights the need to abstract the source of truth for feature functionality into the underlying application logic rather than embedding it in any single interface.
- Uses the example of a reservation system's date field to illustrate how business logic (like blocking weekends) should be centralized and exposed through interfaces appropriately.
- Stresses the distinction between centralized business logic and interface-specific presentation or interaction patterns.
Failover to Human Intelligence
9 months ago
- AI's increasing capability raises concerns about what happens when it fails.
- Current self-driving cars require human monitoring, suggesting complex AI systems might also need human intervention.
- AI-written code may be better documented, but lacks a human author for questions, unlike human-written code.
- Permanent context storage in AI might make it know the codebase better than humans, but reliance on AI raises questions about human intervention.
- The necessity of human intervention challenges the 'full AI takeover' narrative.
- Human intervention implies the need for humans to read, review, and understand code, possibly even writing it.
- The best learning method is by doing, suggesting humans should have a role in code implementation.
- Even non-critical projects could become critical, necessitating human oversight.
- The possibility of human intervention suggests a collaborative future between AI and software developers, not replacement.
OpenIndiana: Community-Driven Illumos Distribution
9 months ago
- Snapshots 2025.04 have been updated.
- Snapshots 2024.10 were updated earlier, with a rolling release approach.
- Release 2024.04 includes updates and new hardware support.
- Announcing OpenIndiana CoWorking Sessions starting this Sunday at 18:00 CET.
- OpenIndiana 2023.10 released, marking the year's closing.
- Security Release 2023.05 issued due to a security issue, urging immediate upgrades.
- OpenIndiana 2023.04 released with nearly 2000 commits since the last release.
- New website and logo unveiled, featuring a previously hidden logo.
- OpenIndiana Hipster 2022.10 released with updates including CPU microcode and BHyVe enhancements.
- Perl versions updated to 5.34 and 5.36, obsoleting older versions.
- lighttpd updated to version 1.4.64, removing deprecated options.
- OpenIndiana 2021.12 SPARC pre-release available for testing.
- OpenIndiana Hipster 2021.10 released, continuing the biannual snapshot tradition.
- OpenIndiana Hipster 2021.04 released with updates from illumos-gate.
Maybe time to stop running software organizations as if we were a reality show
9 months ago
- Allen Holub discusses parallels between dysfunction on Project Runway and in software development teams.
- He notes that the entertainment-driven dysfunction seen in the show mirrors issues in many software shops.
- The post suggests a deeper discussion on these similarities is warranted.
Rust in 2025: Targeting foundational software
9 months ago
- Rust's mission is to make foundational software more accessible to author and maintain.
- Foundational software includes CLI tools, cloud platforms, embedded devices, and kernels.
- Rust combines C++'s zero-cost abstractions with a memory-safe type system.
- Type systems in Rust empower developers at all experience levels.
- Rust is also being used for higher-level applications like GUIs and webpages.
- Projects like Dioxus, Tauri, and Leptos push Rust's boundaries and improve ergonomics.
- Using Rust across the entire stack allows for shared libraries and support code.
- Smooth, iterative deepening is key for user experience in Rust.
- Future focus areas include language interop, type system extensions, and ecosystem leveling up.
AI Doesn't Lighten the Burden of Mastery; AI Makes It Easy to Stop Valuing It
9 months ago
- AI-generated code can create an illusion of mastery by producing syntactically correct but functionally flawed outputs.
- False mastery occurs when developers mistake AI-generated code for real understanding, leading to superficial engagement with the material.
- The danger of false mastery is that it can lead to organizational decay as teams rely on AI without maintaining deep understanding.
- AI tools, while useful, do not eliminate the cognitive burden required for true mastery in software development.
- The real work of mastery involves building mental models, careful reading, and debugging, which AI cannot replace.
Ruby gems still broken after 15 years
9 months ago
- Ruby gems installation has been broken for 15 years, defaulting to system directories instead of user directories.
- A simple fix involves setting `GEM_HOME` to the user directory, but this issue persists due to lack of cohesion between `gem` and `bundler` projects.
- A proposed patch to fix the issue is minimal and non-disruptive, but has been ignored by the RubyGems leadership.
- The RubyGems project leadership has shown resistance to external contributions, including banning a contributor for critical feedback.
- Multiple issues related to gem installation defaults remain unresolved, with temporary or ineffective solutions being implemented.
- Developers and package maintainers often dismiss the issue, suggesting workarounds instead of addressing the root problem.
- The lack of empathy and cooperation among key stakeholders leaves users to manually fix the issue in their environments.
What could have been
9 months ago
- AI discourse is pervasive, with strong opinions on both sides about its impact and future.
- Many AI features added to software are unwanted and degrade user experience.
- Significant resources are funneled into AI, potentially at the expense of improving existing technology.
- Current technology and critical infrastructure are neglected in favor of chasing AI advancements.
- Examples like Gamescom's failed AI meeting generator highlight the mismatch between AI features and user needs.
- Conference networking apps are often broken, yet AI integration is prioritized over fixing core functionalities.
- The motivation behind AI integration is often short-term profit rather than product improvement.
- The 'enshittification' of products is a growing concern, with long-term viability sacrificed for immediate gains.
- Funding for AI could instead support open-source projects and critical software development.
- The opportunity cost of the AI bubble is significant, with years of potential progress lost.
Graphite Chat
9 months ago
- AI has significantly accelerated software development, making code writing faster than ever.
- Graphite introduces Graphite Chat, a new feature for AI-powered code review directly in pull requests.
- Graphite Chat allows developers to understand code changes, ask for improvements, and apply fixes instantly without leaving the PR.
- Features include understanding diffs without manual digging, getting customized suggestions, and making changes quickly.
- Graphite Chat benefits both PR authors and reviewers by providing context, identifying improvements, and resolving issues efficiently.
- The tool is currently in beta and free for all Graphite users, aiming to streamline the code review process.
The Unbearable Slowness of AI Coding
8 months ago
- Initial excitement with Claude Code led to rapid task completion and frequent commits.
- Building a substantial app has slowed the process, despite parallelizing Claude Code instances.
- Reviewing PRs is time-consuming, requiring local application, console log checks, and fixes.
- Despite the speed of code generation, the process feels slow due to QA responsibilities.
- Challenges include ensuring Claude follows rules and performs complex integration tests.
- Current workarounds involve local PR reviews, git hooks for quality, and dealing with hallucinations.
Vibe Debugging: Enterprises' Up and Coming Nightmare
8 months ago
- The author struggles with debugging a meme stock valuation site, facing erratic growth numbers and messy code.
- Attempts to fix the code with AI assistance (Claude Code) lead to distractions and partial fixes, ultimately resulting in the removal of a feature.
- Vibe debugging is criticized, with suggestions to provide full specifications, allow agent questions, and review changes thoroughly.
- AI-assisted coding is seen as both productive and overhyped, with concerns about code quality and security.
- Enterprises are rapidly adopting AI coding tools, leading to an explosion in code volume and potential bugs.
- The need for robust monitoring and logging is emphasized to handle AI-generated code in production.
- CI/CD pipelines must evolve to include more rigorous testing and quality gates to manage AI-generated code.
- The author predicts growth in B2B SaaS spending on monitoring and DevOps tools, as well as a wave of AI-native startups.
- AI progress is seen as non-linear, with plateaus between breakthroughs, requiring current systems to be built for today's AI capabilities.
- The enterprise AI wave is fundamentally reshaping software development practices, demanding new safeguards and oversight.

first prev5next

About|Login

#software development

Choose Boring Technology, Revisited

Code with LLMs and a Plan

Fingine: Thoughts on Side Projects and Financial Simulation

How I use Claude Code to implement new features in an existing complex codebase

How we enforce .NET coding standards to improve productivity

Rust, Python, and TypeScript: the new trifecta

GitHub CEO delivers stark message to developers: Embrace AI or get out

OOP is not Design Patterns

81% of people more wary of dependencies due to AI

UI vs. API. vs. UAI

Failover to Human Intelligence

OpenIndiana: Community-Driven Illumos Distribution

Maybe time to stop running software organizations as if we were a reality show

Rust in 2025: Targeting foundational software

AI Doesn't Lighten the Burden of Mastery; AI Makes It Easy to Stop Valuing It

Ruby gems still broken after 15 years

What could have been

Graphite Chat

The Unbearable Slowness of AI Coding

Vibe Debugging: Enterprises' Up and Coming Nightmare