Bad artists copy, great artists steal—or, how to become a great designer

There‘s a famous quote, often attributed to Pablo Picasso or T.S. Eliot, that "Good artists copy, great artists steal." Steve Jobs was fond of repeating this adage as well. But what does it really mean, and how does it apply to design and web development?

At first glance, the notion of stealing in any creative field seems unethical, even illegal. Plagiarism is obviously wrong. But there‘s an important distinction between copying and stealing when it comes to ideas. Understanding this difference is key to becoming a great designer and developer.

Copying vs. Stealing in Design and Development

To copy is simply to imitate or reproduce something as closely as possible. There is no real creativity involved, just mindless duplication. In contrast, to "steal" in the artistic sense means to take an existing idea, concept, design or piece of code, and use it as a starting point to create something new and original.

When you steal, you‘re not just imitating – you‘re using the original as raw material or inspiration which you then transform and make your own through improvements, adaptations, and remixing it with your own ideas and context. Copying is about resemblance, stealing is about essence.

This concept is particularly relevant in web design and development, where we are constantly building upon and adapting existing solutions. Very rarely does a website or application spring into existence entirely novel and unique. Rather, the best designs and codebases are often clever recombinations and adaptations of proven patterns.

For example, consider some of the most common design patterns in web interfaces:

• Card-based layouts for presenting collections of content or data
• Hamburger menus for navigating on mobile
• Infinite scroll for loading new content
• Skeleton screens for loading states
• Pull-to-refresh interaction for mobile

These patterns weren‘t invented from scratch. They evolved as designers and developers saw effective solutions, adapted them to their own contexts, and iteratively improved upon them. That‘s healthy stealing.

The same applies to common coding patterns and algorithms. Think of things like:

• Model-View-Controller (MVC) architecture
• Representational State Transfer (REST) APIs
• Object-oriented programming (OOP) patterns like factories and singletons
• Functional programming concepts like pure functions and immutability
• Common sorting and search algorithms

No developer today is expected to invent these from first principles. We learn them, we adapt them to our specific use cases, and we combine them in unique ways. That‘s the essence of artful stealing in web development.

The Role of Open Source

This kind of positive stealing is encoded into the very DNA of web development via the open-source software movement. So much of the web today is built on open-source foundations, from operating systems like Linux, to web servers like Apache, to databases like MySQL, to programming languages and frameworks like PHP, Ruby on Rails, and JavaScript.

The open-source ethos is all about stealing in the best sense – taking existing code, learning from it, adapting it, improving it, and sharing those improvements back to the community. It‘s a virtuous cycle of iterative theft that leads to rapid innovation.

Imagine if every web developer had to write their own web server from scratch, or build their own JavaScript framework. We‘d never get anywhere. Instead, we have a vast shared commons of battle-tested code that we can build upon.

As Facebook‘s React library has gained in popularity, its core concepts like componentization and unidirectional data flow have found their way into other frameworks like Angular and Vue. That‘s stealing at work – adapting good ideas to new contexts.

Learning by Stealing

For beginning web developers, one of the best ways to learn is by stealing – in the sense of studying and adapting existing code. When you‘re learning a new language or framework, a great place to start is by finding an open-source project you admire, and digging into its codebase.

See how it‘s structured, how it solves common problems, what patterns and architectures it uses. Then try to replicate parts of it yourself. Rebuild a single component or feature. Adapt it to a different use case. Extend it with new functionality.

This kind of focused, analytical stealing is a powerful way to absorb best practices and train your own problem-solving muscles. You‘re not just mindlessly copying, but actively learning and adapting.

The popular coding challenge site Frontend Mentor works on this exact principle. It provides professional designs, and challenges you to implement them yourself with HTML, CSS, and JavaScript. You‘re essentially stealing the design, but the coding is all you. It‘s a great way to practice turning design concepts into code.

Here‘s an example. Let‘s say you‘re learning React, and you come across this clever bit of code for a toggle component:

function Toggle({ label, initialOn = false }) {
  const [on, setOn] = React.useState(initialOn);

  function handleClick() {
    setOn(!on);
  }

  return (
    <>
      <label>
        <input
          type="checkbox"
          checked={on}
          onChange={handleClick}
        />
        {label}
      </label>
      <div>{on ? "ON" : "OFF"}</div>
    </>
  );
}

You could just copy and paste this into your project. But to really steal it artfully, you would:

1. Study it and understand how it works. Trace the flow of props and state, see how the click handler toggles the state, how that state is used to conditionally render the ON/OFF text.

2. Adapt it to your context. Maybe you need it to toggle between "Yes" and "No" instead of "ON" and "OFF". Make that change.

3. Extend it with new functionality. Maybe you need it to fire an event to the parent component when toggled. Add that in.

4. Refactor it to your coding style. Maybe you prefer named function declarations to arrow functions. Rewrite it that way.

By the end of this process, you‘ll have made it your own. You‘ll deeply understand how it works, because you‘ve actively engaged with the code, not just duplicated it.

The Perils of Copying

It‘s worth noting that there is a wrong way to steal code, which is when it crosses the line into mindless copying without understanding.

We‘ve all seen this in action – a novice developer copies a chunk of code from Stack Overflow, pastes it into their project, and then wonders why it doesn‘t work. Or worse, it does work, but they have no idea why, and now they‘re stuck with a magical chunk of code they‘re afraid to touch.

This is the coding equivalent of cargo cult programming – imitating the superficial aspects of something without understanding the underlying mechanisms. It‘s like painting racing stripes on your car and expecting it to go faster.

Copying code without understanding it is a recipe for buggy, inefficient, and unmaintainable software. It‘s how you end up with massively bloated SPAs that grind to a crawl, or back-end services that crumple under real-world traffic.

When you artfully steal code, you‘re not just blindly copying. You‘re internalizing the underlying patterns and principles. You can adapt it, debug it, extend it, and most importantly, know when it‘s not the right solution at all.

Stealing Gone Wrong

There are also times when stealing in web development can cross ethical and legal lines. Copying an entire website design wholesale and just changing the logo is not artful theft, it‘s plagiarism (and potentially copyright infringement).

Likewise, stealing proprietary code and passing it off as your own is not just unethical, but could get you into real legal trouble. Always be aware of the licensing of any code you‘re adapting, and make sure you‘re respecting the terms of use.

There‘s also a danger of over-reliance on stealing leading to homogeneous, cookie-cutter designs and codebases. If everyone is just copying the same Bootstrap template, the web starts to look very samey. Artful stealing should be a starting point for creativity, not an end in itself.

As Jen Simmons, designer advocate at Mozilla, puts it:

Steal ideas, not implementations. Steal the essence behind a design, not the pixels. Steal the underlying principles, not the surface-level specifics.

Steal Like a Full-Stack Developer

So what does artful stealing look like for a full-stack web developer specifically? It‘s about being omnivorous in your sources of inspiration, and strategic in how you adapt them.

A great full-stack developer should have a wide-ranging toolkit of patterns and solutions they can draw upon and remix as needed. This means constantly expanding your knowledge across the stack – from UI/UX design patterns, to front-end architectures, to back-end services, to devops and deployment strategies.

It means being comfortable stealing from one layer of the stack and adapting it to another. Maybe you see a clever state management solution in a React component and adapt it to manage server-side state in your Node.js API. Or you take a smooth animation technique from a native app and figure out how to replicate it with CSS.

It also means knowing how to evaluate what‘s worth stealing. A shiny new JavaScript framework may be getting a lot of hype, but does it actually solve a real problem for your use case? A slick UI interaction may look cool, but does it actually improve usability, or is it just eye candy?

A great full-stack developer is always asking these questions, always evaluating and curating their mental library of stealable ideas.

Conclusion: Steal Your Way to Greatness

Picasso and Jobs were right – great artists and innovators steal. But they steal strategically, with understanding, and with the intent of transforming their theft into something new and original.

For web designers and developers, artful stealing is a core skill. The web is a massive, open, constantly evolving collective project, and we‘re all standing on the shoulders of giants. By learning to steal the right way – with curiosity, with attribution, with improvement in mind – we can innovate faster and build better together.

So go forth and steal like an artist. Steal like a craftsman. Steal like a full-stack developer. Just make sure you‘re stealing the essence, not just the surface. Steal the principles, not just the pixels. And always, always make it your own.

As the great design thief Steve Jobs once said:

"We have always been shameless about stealing great ideas."

Shameless, but not indiscriminate. Steal with taste, steal with intention, steal with transformation in mind. That‘s the art of the steal.