10 Simple Rules for Beginners to Write Better Code

Introduction: What Is Clean Code and Why Should You Care?

Writing code isn’t just about making it work—it’s about making it readable, understandable, and maintainable. That’s what clean code is all about.

Think of clean code like good handwriting. Anyone (including future-you) should be able to look at your code and quickly understand what it does—without guessing or deciphering it like a secret message.

What You’ll Learn

By the end of this post, you’ll walk away with:

• 10 simple rules that will instantly improve your code
• Examples that show what clean vs messy code looks like
• Practical habits you can build as a developer

A Simple Definition

Clean code is code which is:

• Easy to read — you (or someone else) can understand what it does without digging through every line
• Easy to maintain — you can update or improve it without breaking everything
• Easy to debug — when something goes wrong, it’s simple to figure out where and why

It doesn’t have to be fancy. In fact, the best clean code is often simple and boring—and that’s a good thing.

Why Clean Code Is Important

Clean code isn’t just about neatness. It has real benefits:

• You save time
  Messy code slows you down when you’re trying to add features or fix bugs.
• You avoid confusion
  Six months from now, you won’t remember what tmp2 or checkStuff() means. Clean code explains itself.
• You work better in teams
  Other developers can read and work with your code without needing a personal walkthrough.
• You grow your career faster
  Writing clean code shows you care about quality. Hiring managers and senior devs notice that.

Think of This Analogy

“Messy code is like a cluttered room. You can’t find what you need, and everything feels frustrating. Clean code is like a tidy, labeled workspace—everything’s where it should be, and you can get work done faster.”

Just like you don’t leave clothes on the floor if you want to keep your room clean, you shouldn’t leave random, confusing code lying around either.

Clean code isn’t about being perfect—it’s about being thoughtful. And anyone, even a beginner, can start writing clean code by following a few simple habits. Let’s look at those next.

10 Simple Rules to Write Clean Code

Writing clean code doesn’t mean you need to be an expert. It just means writing in a way that’s easy for others (and future-you) to understand. Let’s look at 10 beginner-friendly rules you can start using today.

1. Use Meaningful Variable and Function Names

Your code should speak for itself. Avoid generic names like x, foo, temp, or data.

Instead, use names that clearly describe what the variable or function does.

Good Examples:

• totalPrice instead of tp
• getUserData() instead of doStuff()

💡 Quick Tip:

If you have to explain what the name means, it’s not a good name.

Well-named variables and functions reduce the need for extra comments and make your logic easier to follow.

2. Keep Functions Short and Focused

Each function should do one thing and do it well. If your function is scrolling off the screen, it probably does too much.

This follows the Single Responsibility Principle — a fancy way of saying: “One function = one job.”

❌ Messy Example:

function handleUserLoginAndSendEmailAndLogActivity() {
  // Too much going on!
}

✅ Clean Example:

function handleUserLogin() { ... }
function sendWelcomeEmail() { ... }
function logUserActivity() { ... }

Smaller functions are easier to test, debug, and reuse.

3. Write Comments Only When Necessary

Comments are helpful, but they’re not a substitute for good code. Your goal should be to write code that doesn’t need a comment to be understood.

❌ Bad Practice:

// Add 1 to counter
x = x + 1;

✅ Better:

itemCount = itemCount + 1;

Now the code explains itself. Save comments for why something is done—not what it does (unless it’s really complex logic).

4. Consistent Formatting and Indentation

Even if your code works, messy formatting can make it hard to read. Keep things tidy:

• Use consistent indentation (usually 2 or 4 spaces)
• Break long lines into readable chunks
• Stick to a clear structure

You don’t need to do this manually. Use tools to format your code automatically:

• Prettier – formats your code
• ESLint – finds and fixes issues in JavaScript
• Editor auto-formatting – most editors (like VS Code) can format on save

✅ Before vs After Example (JavaScript):

Before:

function add(a,b){return a+b;}

After:

function add(a, b) {
  return a + b;
}

Small changes make a big difference in readability—especially when working on a team.

More Simple Rules to Keep Your Code Clean

Let’s continue with four more clean code rules that will make your code easier to read, debug, and maintain—especially as your projects grow.

5. Avoid Deep Nesting

Too many layers of if statements or nested loops make your code hard to follow. It quickly becomes a tangled mess.

❌ Example of Deep Nesting:

if (user) {
  if (user.isActive) {
    if (!user.isBanned) {
      // Do something...
    }
  }
}

✅ Cleaner Approach Using Early Returns:

if (!user || !user.isActive || user.isBanned) return;

// Do something...

You can also split complex logic into smaller helper functions. This makes your main code easier to understand at a glance.

6. Use Descriptive Error Messages

When something goes wrong, vague errors like "Error" or "Failed" won’t help you (or anyone else) figure out the problem.

Write error messages that clearly explain what happened and why.

❌ Bad:

throw new Error("Failed");

✅ Good:

throw new Error("User login failed: Invalid password");

This makes debugging faster and helps users or teammates understand issues more easily.

7. Remove Dead or Unused Code

Commented-out blocks of old code, unused functions, and leftover variables create clutter. They don’t add value and make your file harder to read.

Example:

// oldLoginFunction(); // kept just in case

Clean code means lean code. If you’re not using it, delete it. You can always find it later in version control (like Git) if needed.

8. Use Constants for Magic Numbers and Strings

Magic numbers are unexplained values in your code—like 3, 500, or 'active'—that appear without context. They’re confusing and error-prone.

❌ Example:

if (status === 3) {
  // do something
}

✅ Better:

const STATUS_APPROVED = 3;

if (status === STATUS_APPROVED) {
  // do something
}

Constants:

• Make your code more readable
• Prevent typos and repetition
• Make updates easier (change the value in one place)

Use named constants for any hardcoded number or string that isn’t self-explanatory.

9. Group Related Code Together

Keep related code close together. This includes:

• Variables and functions that work on the same task
• Logic that belongs to a specific feature or component

This makes your code easier to navigate, understand, and modify.

❌ Scattered Code Example:

function calculateTotal() { ... }

const userName = "Alex";

function getUserCart() { ... }

const cartItems = [/* ... */];

✅ Grouped Code Example:

const userName = "Alex";
const cartItems = [/* ... */];

function getUserCart() { ... }
function calculateTotal() { ... }

When things are grouped logically, it’s easier to follow the flow and spot errors or improvements.

10. Test and Refactor Often

Once your code is working, don’t stop there. Take a few minutes to clean it up. That process is called refactoring.

Refactoring means improving the structure of your code without changing what it does.

🛠️ Simple Example:

Before (Messy but Functional):

function handleUser(user) {
  if (user.isAdmin) {
    return "Admin";
  } else {
    return "User";
  }
}

After (Clean and Concise):

function handleUser(user) {
  return user.isAdmin ? "Admin" : "User";
}

You can refactor by:

• Renaming variables
• Splitting large functions
• Removing duplication
• Reorganizing code into reusable components or modules

Refactoring regularly keeps your codebase healthy and saves you pain later when adding new features or fixing bugs.

Common Mistakes Beginners Make (And How to Avoid Them)

Even with the best intentions, it’s easy to fall into bad habits when you’re starting out. Here are some common mistakes new developers make—and how to fix them.

Over-Commenting

Adding comments for everything, even when the code is already clear, can clutter your file.

Instead: Focus on writing self-explanatory code and only comment when something truly needs clarification.

// ❌ Don't do this
// Add 1 to item count
itemCount = itemCount + 1;

// ✅ Do this instead
itemCount++;

Copy-Pasting Without Understanding

It’s tempting to grab code from Stack Overflow or ChatGPT and just plug it in.

Instead: Take a moment to read and understand what the code is doing—so you can debug or change it later if needed.

Writing Too Much Logic in One Function

Long, complex functions are hard to read and harder to test.

Instead: Break large blocks of logic into smaller, focused functions that each handle one task.

Simple Clean Code Example: Before vs After

Let’s look at a real-world example: a basic login check.

Messy Version:

function check(data) {
  if (data.user !== undefined && data.pass !== undefined) {
    if (data.user.length > 0 && data.pass.length > 0) {
      if (data.user === "admin" && data.pass === "1234") {
        return true;
      }
    }
  }
  return false;
}

Hard to read, right? Let’s clean it up.

Clean Version:

function isValidLogin(data) {
  const { user, pass } = data;

  if (!user || !pass) return false;
  if (user !== "admin" || pass !== "1234") return false;

  return true;
}

What Changed and Why:

• Function name is clearer (isValidLogin)
• Used early returns to avoid deep nesting
• Destructured input for easier access
• Improved readability without changing behavior

Clean code isn’t just about style—it’s about making your logic easier to follow and maintain. And as you can see, even small changes can make a big impact.

Tools That Help You Write Clean Code

You don’t have to clean up your code manually—there are great tools that do a lot of the heavy lifting for you. These tools help format your code, catch issues early, and keep things consistent across your team.

Here are some beginner-friendly tools to get started:

Prettier – Code Formatter

What it does: Automatically formats your code to look clean and consistent.

• Fixes indentation, spacing, quotes, and line breaks
• Works with most languages: JavaScript, HTML, CSS, etc.
• Saves time and prevents messy formatting

Example:
You write this:

function sayHello(name){console.log("Hi, "+name);}

Prettier changes it to:

function sayHello(name) {
  console.log("Hi, " + name);
}

Get it: https://prettier.io

You can also install it in VS Code and enable format on save.

🛡️ ESLint – JavaScript Linter

What it does: Checks your JavaScript code for errors and style issues.

• Warns you about unused variables, bad practices, or inconsistent style
• Helps you follow coding standards
• Works great with Prettier

Example warning:

const name = "Alex"; // ESLint: 'name' is assigned a value but never used.

Get it: https://eslint.org

Combine ESLint + Prettier for a super clean code workflow.

⚙️ EditorConfig – Consistent Settings Across Editors

What it does: Makes sure your indentation, line endings, and spacing stay the same—no matter which editor you or your teammates use.

• Ideal for teams or switching between devices
• Works with VS Code, Sublime Text, Atom, and more
• Simple .editorconfig file at the root of your project

Example .editorconfig:

root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8

Get it: https://editorconfig.org

🧠 Why Use These Tools?

• You write less boilerplate
• You stay consistent without thinking
• You catch errors before they become bugs

Start with just one tool (like Prettier) and build from there. Over time, these tools become a natural part of your workflow—and your code will always look clean without extra effort.

Conclusion

Writing clean code is more than just a nice-to-have—it’s essential for your success as a developer. Clean code makes your projects easier to maintain, helps you avoid bugs, and improves teamwork. Most importantly, it saves you time and frustration in the long run.

You don’t need to master all 10 rules at once. Even applying 2 or 3 simple rules today—like meaningful names, short functions, or consistent formatting—can make a big difference.

Remember, clean code is a skill that grows with practice. The more you write and refactor, the better you’ll get at it. Every small improvement counts!

Which clean code rule will you start applying today? Share your thoughts or questions in the comments below! And if you found this helpful, don’t forget to subscribe for more tips on coding smarter and growing your career.