I just read Matthias Endler's article on the traits of the best programmers he knows. It's a great article from an open source vet and he covers important points about reading documentation, continuous learning, and breaking down problems. But in my opinion, he missed something crucial: great programmers understand business problems, not just technical ones.

1. Think Like a Product Manager

Great engineers have product management skills because product management is fundamentally about understanding users.

They don't rely on secondhand remarks from a PM. They pore over the analytics, observe real users, conduct their own interviews, and build empathy for customer problems. The engineer who spends an afternoon watching five users struggle with a feature will make better decisions than one who spends a month refactoring code nobody complains about. The Amazon team that built the one-click purchase button didn't do it because it was an interesting programming challenge. They did it because they measured how many sales were lost in a multi-step checkout and understood the business impact of reducing friction.

Engineers without product sense build solutions nobody wants. Even worse, they overengineer code that nobody asked for.

2. Learn What Drives Revenue

Smart engineers know which metrics pay their salary.

If you don't understand CAC, LTV, and conversion rates, you're just a cost center. When you propose a new feature, frame it in terms of business impact, not technical interest. At Twitch, engineers who understood viewer engagement metrics built features that directly increased watch time and ad revenue. Their colleagues who didn't were relegated to maintenance work.

Companies optimize for profit, not code elegance.

3. Ship Beats Perfect

A flawed product that earns money today beats a perfect one that ships next year.

Recognize when to accumulate technical debt strategically. Instagram launched with a fraction of the features they planned because they knew market timing mattered more than completeness. Startups that wait for perfect die while messy competitors capture the market. Facebooks' early code certainly wasn't pretty. But it worked when it needed to.

The market doesn't reward what you could have built.

4. Align With Company Strategy

Engineers who understand business strategy get resources and recognition.

If you know the three-year plan, you'll make technical choices that support it rather than fight it. The most successful engineers I've known don't just attend strategy meetings—they shape them. They connect technical possibilities to business opportunities in ways non-technical executives can't. Their value isn't in writing code that works, but in writing code that matters.

Strategic engineers build moats, not monuments.

5. More important than ever in an AI-Assisted World

Technical coding skills alone are becoming commoditized.

When AI assistants can generate functional code quickly, you need additional differentiators to remain valuable. Understanding business problems and translating them into technical solutions becomes your competitive advantage. Engineers who combine technical competence with business acumen can direct AI tools toward meaningful outcomes while others merely produce code without purpose. The most successful engineers today use AI to handle routine tasks like documentation and unit tests, freeing their mental bandwidth to focus on product strategy and user value creation.

Don't get me wrong, deep understanding of code and architecture is still highly valuable and necessary, maybe now more than ever in this landscape of vibe coders and AI app builders like Replit. But there is a ton of value in knowing which code matters to the business.

Technical skills are incredibly important. But they cannot be the only lens through which to view things because as an engineer you are always constrained by time and cost. Too many engineers sacrifice shipping at the altar of Clean Code and Clean Architecture. Business acumen gets you to the next level of your career, or even better - unlocks the ability to build and launch your own product.

Build, don’t just consume

I spent years as a tutorial collector. I'd see a $497 "Ultimate Developer Bundle" and my credit card would practically leap out of my wallet. I'd start one course, finish it about half-way, get bored and somehow never build anything substantial on my own.

The cruel irony of our industry is that tutorials rarely create competence. They create the illusion of progress—comfortable, structured, risk-free progress.

When AI entered the scene, many developers just found a new way to not learn. "Build me a Twitter clone" prompts and vibe-coding just exchange tutorial addiction for a different kind of non-learning. The solution isn't having AI do all the thinking for you; it's having AI teach you to write better code yourself (which you can then use to instruct it better).

I've developed a system that uses AI as a mentor rather than a crutch. Think of it as pair programming with a senior developer who refuses to touch your keyboard.

Step 1: Set tight constraints

Pick something specific to learn and strictly timebox it to 1-2 hours. This isn't arbitrary—it's psychological warfare against your own tendency to abandon projects. If you can't finish it in one deep work session, you probably won't finish it at all.

Step 2: The AI Project Scaffold Method

Use this prompt to establish the mentorship dynamic:

You are a Senior Software engineer who is an expert in mentoring junior developers.

I'd like you to serve as my mentor for a coding project I want to build in 1-2 hours. This should be a focused learning experience where:

## Your role:

- Provide a high-level implementation plan with major components and architecture

- Focus on helping me learn 1-2 specific skills or concepts through this project

- Do NOT provide actual code examples or step-by-step tutorials

- Be available to answer my questions, but guide me toward solutions rather than solving problems for me

- Push me outside my comfort zone enough to promote growth, while keeping the scope achievable

- Act as a sounding board for my ideas and implementation approaches

- Provide constructive feedback that challenges my thinking

- Maintain a running project log that tracks:

	- What we've accomplished so far

	- Current challenges/blockers

	- Next steps

	- Key learning moments

## My role:

- Do the actual implementation work myself

- Ask specific questions when I'm stuck

- Share my progress and challenges

- Make the key architectural and implementation decisions

I want to learn [specific technology/concept] by building [type of project]. My current skill level is [beginner/intermediate/advanced] with experience in [relevant technologies].

Help me design an appropriately challenging project that will teach me valuable skills in a condensed timeframe without handholding or excessive guidance.

The magic is in what this doesn't do. It doesn't solve problems for you. It doesn't write your code. It maintains that critical zone where learning happens—just challenging enough to force growth, just supportive enough to prevent surrender.

Step 3: Embrace productive struggle

This is where actual learning happens. Use documentation. Use the web. Feel frustrated. The point is to struggle on your own but with a safety net.

When continuing a session in a different chat, use this prompt to maintain context:

# Project Continuation Prompt

I'd like to continue a mentoring session from a previous chat. Here's what you need to know:

## Project Context:

- We're working on: [describe project type/purpose]

- Core technologies/concepts: [list key techs/concepts]

- My skill level: [beginner/intermediate/advanced]

- Time frame: [remaining time from 1-2 hour goal]

## Current Project Log:

- Completed tasks: [list what's been accomplished]

- Current implementation stage: [describe where you left off]

- Key challenges encountered: [list any blockers/issues]

- Next steps planned: [what you were about to work on]

- Learning goals: [1-2 specific skills being developed]

## Your role as Senior Software Engineer/mentor:

- Provide high-level guidance without code examples

- Focus on helping me learn through doing

- Answer questions but guide rather than solve

- Maintain our project log as we continue

- Push me enough to grow but not enough to give up

Let's continue where we left off with the same coaching approach - challenging me while supporting my learning journey.

Step 4: Engage the AI in conversation. Be curious

The depth of your learning comes from understanding why decisions are made, not just how to implement them:

- "Why did we choose X framework?"

- "What happens if I don't validate JWT tokens in the middleware?"

- "What is the point of catching these errors?"

- "Why do we need extensive logging?"

These questions transform mechanical code-copying into architectural understanding.

Step 5: Complete the project

This is why small scope matters. Finishing builds confidence. Partial projects build frustration.

Step 6: Teach what you learned

Document your journey. Explain it in a blog post. Visualize it. The act of teaching cements your learning in a way that passive consumption never will.

The Real Value

This approach yields:

- Actual, working code you built yourself

- A GitHub project that demonstrates real skills

- Deeper learning through teaching others

- A fraction of the cost of premium courses

- Respect for your time—no 8-hour video series

The most painful truth about programming is that you can't learn it by watching others. You have to write the code, hit the errors, and solve the problems. AI can now serve as the mentor who creates the right learning environment—challenging without overwhelming, supportive without solving.

You wouldn't expect to learn piano by watching YouTube tutorials. Why expect it with code?

Introduction

Picture this: It's 3 AM, you’re surrounded by a fortress of energy drink cans, and you’re slowly going insane trying to center a div. We've all been there. But what if I told you that while you're wrestling with CSS, AI could have built three landing pages, generated a week's worth of unit tests, and probably written better documentation than that "TODO: fix this later" comment you left six months ago?

Welcome to the AI era. The hype isn’t just real, it's your new pair programmer.

In this guide, we'll cut through the BS and focus on practical, battle-tested strategies that will transform your development process. Whether you're a seasoned developer or just starting out, you'll learn how to leverage AI tools to ship code faster – without sacrificing quality or control. Let's dive in.

The Modern AI Development Stack (as of December 2024)

The AI development landscape has grown significantly, with clear leaders emerging in each category. Here’s my current tech stack.

Research and Exploration

• Perplexity - Real-time AI research assistant

• Claude API (via Typing Mind) - In-depth technical analysis

Planning

• ChatGPT - Project planning and roadmapping

UI Scaffolding

• Bolt.new - Rapid UI prototyping and generation

• Boilerplate templates - My own custom, framework-specific templates

Development

• Cursor - AI-powered code editor

Debugging

• Repomix - Package up your code for easy LLM consumption

• Cursor and Perplexity

The AI-Powered Development Process

Research and Exploration Phase

Gone are the days when research meant endlessly scrolling through random web forums. The landscape has completely transformed.

Perplexity has become an essential partner in the exploratory phase. It’s my go-to research companion, a sophisticated search engine that actually understands context. Instead of having to piece together information from multiple sources yourself, it synthesizes knowledge in real-time, helping you understand anything. It's particularly brilliant when you're trying to understand a new technology or researching the feasibility of an idea. The best part is that it’s up to date, unlike other LLMs which have knowledge cut-offs.

For deeper dives, I've found the combination of Claude API with Typing Mind to be incredibly powerful. Claude Sonnet 3.5 in my estimation is currently the best LLM for general programming. Typing Mind on the other hand is a wrapper for your LLM APIs, not too dissimilar from ChatGPT’s web interface. It provides a ton of amazing functionality including prompt management and powerful extensions. I primarily use Claude to get a general idea of how to implement a difficult technical task such as AI agents or cloud infrastructure.

Planning Phase

Planning has never been the most exciting part of any project.

ChatGPT, particularly with the latest o1 model, has become surprisingly adept at planning and breaking down ambitious projects into digestible chunks. Feed it your project requirements, and ask it to help you craft a realistic roadmap and timeline that actually makes sense – no more "yeah, we can build Facebook in two weeks" estimates.

The key here is focusing on the lean MVP approach. It's like having a pragmatic product manager who isn't emotionally attached to that one feature everyone thinks they need but no one will actually use. The AI helps prioritize what truly matters for your MVP or feature, keeping you focused on shipping rather than getting lost in the endless sea of "nice-to-haves."

Another tip- have o1 break down your tasks by week for a straightforward, actionable to do list, all without having to touch Jira or hire a project manager.

UI Scaffolding

This is where things get really interesting. Bolt.new has completely changed the game when it comes to initial UI development. Imagine describing what you want in plain English and getting a fully functional UI in return – it's like having a UI designer and front-end developer at your beck and call. Now combine this with a boilerplate template from Github and you have the recipe for truly rapid prototyping. I’m taking hours, not months for a full-fledged MVP.

As of writing, Bolt currently isn’t at a stage where it can successfully build full-stack - it’s backend capabilities are still lacking. But for quick UI prototyping it is second to none. v0.dev is a good option as well but I’ve found Bolt to be less buggier and more versatile.

Development Phase

Cursor has emerged as the definitive AI-powered IDE. Its strength lies in understanding your entire codebase as a coherent system rather than isolated files. It’s got auto-complete and built-in chat, similar to Github Copilot. But it truly shines with the Composer feature, a tool that creates and edits multiple files at once. In agent mode, it literally spins up entire features in the blink of an eye.

There are many techniques to optimize Cursor use which I’ll document in an upcoming article. But one easy thing you can do to get started is to create a .cursorrules configuration file in the root of your project, that allows you to define project-specific patterns and preferences, essentially teaching the AI your team's coding standards.

Debugging Phase

Debugging has evolved significantly with the emergence of AI-powered tools.

Cursor serves as an excellent first line of defense, handling many common coding issues directly in your editor with its integrated AI capabilities.

When faced with newer issues, particularly those related to recent package updates or newer frameworks, Perplexity AI proves invaluable. Its real-time search and analysis capabilities help you find current solutions and workarounds, especially useful when dealing with breaking changes or newly reported bugs.

If you're tackling more complex issues that require deeper codebase understanding, Repomix offers a unique approach. By automatically packaging your code in an AI-friendly format, it enables large language models like Claude or ChatGPT to analyze your entire codebase context. This comprehensive view allows them to provide more targeted and effective solutions than traditional document-based debugging approaches.

With these tools, debugging has become easier than it’s ever been. What once caused endless frustration (and possibly a few keyboard-shaped dents in the wall) can now be approached systematically and solved efficiently, letting developers focus on what matters most: building great software.

Key Tips for Success

Master AI-Enhanced Learning

The most successful developers in the AI era aren't those who blindly copy-paste code – they're the ones who use AI as a learning accelerator. While AI can generate solutions quickly, understanding the underlying principles is what sets exceptional developers apart. Use AI to explain complex concepts, break down unfamiliar patterns, and explore alternative approaches. This deeper understanding will help you move faster and make better architectural decisions.

Maintain Critical Oversight

AI is a powerful ally, but it's not infallible. Develop a systematic approach to working with AI-generated code:

1. Review code thoroughly, especially around business logic and security-sensitive areas

2. Run comprehensive tests, including edge cases AI might have missed

3. Profile performance implications of AI suggestions

4. Validate architectural decisions

Pro-tip: ask the AI to generate tests and documentation to ensure accurate and optimal responses.

Stay Adaptable and Current

We're in the Wild West of AI right now. Success requires staying agile: experiment with new tools regularly, share discoveries with your team, and maintain a continuous learning mindset. The landscape changes weekly, but the fundamentals of good engineering remain constant.

Other Tools

Tools I’ve Dropped (for now)

• v0.dev

  • Buggy, UI generation

  • Redundant with Bolt.new

• GitHub Copilot

Haven’t tried, but interested

• Windsurf

• Replit

• ChatGPT’s search functionality (as compared to Perplexity)

• Lovable

• Gemini 2.0 Multi-modal API

Conclusion

Remember that time when Copilot’s auto-complete felt like magic? We're living through something far bigger now. AI isn't just transforming software development – it's rewriting the rules of what's possible in a day's work. But here's the plot twist: the most powerful tool is still the one between your ears.

The real winners in this AI revolution aren't the developers who can prompt the fastest or generate the most code. They're the ones who've mastered the art of the human-AI tango – knowing when to let AI take the lead on the grunt work, and when to step in with the creative problem-solving that machines still can't touch.

Start small. Pick one piece of your workflow that's been driving you nuts, and let AI help shoulder the load. Experiment, fail fast, and build your own rhythm. As these tools evolve at breakneck speed, you'll want to be the developer who's surfing the wave, not the one watching from the shore.

The future of coding isn't human vs. AI – it's human and AI, in perfect harmony.

In the world of software engineering, technical skills are often emphasized as the primary path to improvement.However, there's a powerful tool that's often overlooked in a developer's toolkit: writing. Enhancing your writing skills can significantly boost your effectiveness as a software engineer.

Now I know what you’re thinking - engineering is already tough - now I need to learn how to write as well? But the advantages of writing are so beneficial that ignoring it would be a missed opportunity.

Why Write?

1. Writing Helps You to Clarify Your Thought Process and Think Clearly

When you write, you're forced to organize your thoughts in a logical, coherent manner. This process of structuring your ideas on paper (or screen) can reveal gaps in your understanding or flaws in your logic that might not be apparent when the concepts are just floating around in your head. By articulating your ideas in writing, you're essentially debugging your thought process, leading to clearer, more refined solutions to complex problems.

2. Writing Helps You to Pick Up Where You Left Off

Software development often involves juggling multiple tasks and projects. This constant context switching can often leave developers feeling frazzled and it’s easy to lose track of where you were in your thought process when you return to a project after some time away. Detailed notes and documentation act as a mental anchor, allowing you to quickly reorient yourself and resume work efficiently. This is particularly valuable when dealing with complex systems or long-term projects.

3. Writing Helps Communicate Your Ideas to the Rest of the Team

In collaborative environments, clear communication is key. Writing allows you to articulate your ideas, proposals, and solutions in a format that can be easily shared and understood by your teammates. Whether it's explaining a new feature, proposing an architectural change, or documenting a bug fix, well-written explanations ensure that your ideas are accurately conveyed to others, reducing misunderstandings and promoting smoother collaboration.

4. Writing Helps You Solicit Feedback from the Team

When you put your ideas in writing, you create a concrete artifact that others can review, comment on, and critique. This written format allows for asynchronous feedback, giving team members time to thoroughly consider your proposals and provide thoughtful responses. It also creates a record of the discussion, which can be valuable for future reference or for onboarding new team members.

Documents are also a great vehicle for catching any errors, mistaken assumptions or anything was missed in the planning. Time and time again it has saved my butt on many occasions.

5. Writing Helps Provide a Reference You Can Keep Coming Back To

Software development is often iterative, and decisions made early in a project can have long-lasting impacts. By documenting your thought processes, decisions, and the rationale behind them, you create a valuable resource that you and your team can refer back to throughout the project's lifecycle. This can be particularly helpful when revisiting old code, troubleshooting issues, or considering future enhancements.

Also, for smaller teams with constant turnover, this documentation can be life-saving. A big org can absorb the loss of a single senior engineer but for a tiny startup - this could literally put them out of business. Well-written documents helps ease any transition.

6. As You Level Up In Your Career, Planning Becomes More Important

It is often said that engineers write less code the more senior that they get. At the higher levels of the profession, the bulk of the job shifts to planning - designing systems for scale, assessing trade-offs, weighing which technologies to use and thinking of what could go wrong.

Writing is your greatest ally in this high-level decision-making. Choosing to forego it may mean putting a ceiling on your career.

7. Good writing is the key to unlocking better results from AI

As AI gets better every day, your ability to articulate your problems and clarify your requirements to the LLM makes the difference between amazing and mediocre results. AI is the great gamechanger. It’s changing the world as we know it. Prompt engineering is one of the techniques which help produce the most useful results from the models. And surprise, surprise - good writing matters more than ever. AI may be smart but it can’t give you the answer if it doesn’t understand what you’re asking for.

Practical Tips for Incorporating Writing into Your Software Engineering Practice

1. Create a Document for Every Ticket. Write Out a Detailed Plan

Before diving into coding, take the time to create a document for each ticket or task you're working on.

It doesn’t have to be complicated. This is not middle school - we’re not looking for a thousand word essay here. For most tickets, a simple checklist or bullet points of goals and to dos can be a gamechanger.

Use this document to outline your approach, consider potential challenges, and plan your implementation strategy. This practice not only helps you think through the problem more thoroughly but also provides a reference for you and your teammates as the work progresses.

2. Take Advantage of Commonly Used Documents in Software Engineering

The software engineering field has developed several standard document types that can help structure your thinking and communication. In a lot of bigger orgs with more standardized procedures, you might in fact already be required to do these things. Familiarize yourself with these and use them to your advantage:

a) Design Documents: Use these to outline the architecture and high-level design of your software. They help you think through system components, interactions, and potential trade-offs before you start coding.

b) Requirements Specification: This document helps clarify what the software needs to do, ensuring that you and your stakeholders are aligned on expectations. Writing detailed requirements forces you to consider edge cases and potential issues early in the development process.

c) API Documentation: Ever used a public API with documentation that looks like it was put together by a fortune cookie writer having a bad day? Terrible documentation can be infuriating and turns people away from using your product. Clear, comprehensive API documentation is crucial for both internal and external developers. Writing this documentation often reveals inconsistencies or areas for improvement in your API design.

d) Technical Specifications: These documents dive into the nitty-gritty details of how a feature or system will be implemented. Writing tech specs helps you think through the implementation details and potential challenges before you start coding.

e) Post-mortems or Incident Reports: After resolving a major issue or outage, writing a detailed report helps you and your team learn from the experience and prevent similar problems in the future. You could even go the extra mile and write a pre-mortem, outlining what could go wrong and planning contingencies.

f) Runbooks: These are step-by-step guides for carrying out specific operations or troubleshooting common issues. Writing runbooks forces you to think through processes systematically and can be invaluable for maintaining system reliability and reducing mean time to recovery (MTTR) during incidents.

g) Deployment Checklists: Creating and maintaining deployment checklists ensures that all necessary steps are followed during the deployment process. Writing these checklists helps you anticipate potential issues and standardize your deployment procedures, leading to more reliable and consistent releases.

By incorporating these writing practices into your software engineering workflow, you'll find that your thinking becomes clearer, your communication more effective, and your overall productivity enhanced. Remember, becoming a better writer is a skill that develops over time. Start small, perhaps by documenting your daily work or writing brief design proposals, and gradually expand your writing practice.

Don’t be intimidated. Nobody is expecting Shakespeare. Be clear and concise, using only the words you need. Avoid drowning your subject in technical babble or corporate buzz speak. Think Hemingway, not James Joyce.

So, embrace writing as a powerful tool in your developer toolkit— your next best career move might be learning how to write better English, not better Rust.