It’s a question we hear a lot from newcomers who are just discovering Loops & Logic. If Loops & Logic is an abstraction of PHP—a reimagining of its capabilities using simple HTML syntax—why should someone learn to write L&L templates when they could spend that time learning to write PHP instead? And since PHP is the foundation of WordPress, won’t PHP always be the better language?

There are plenty of reasons why someone might choose to work with PHP instead of L&L and just as many reasons to choose L&L over PHP. The choice between learning and using one language over the other will always depend on the project. In this article, we’ll explore why many agencies, including our own, have opted to use Loops & Logic despite the greater theoretical capabilities of PHP.

Everyone is more efficient when they play to their strengths

There are a wide array of skill types on any given team. At our WordPress agency, we’ve found that one single designer can create enough designs to keep five front-end implementers busy, and one front-end implementer can keep five back-end developers busy with features they need to achieve their goals. This won’t be the same for every agency—an agency that builds enterprise WordPress apps is going to have a different breakdown than one that builds brochure sites—but that’s the distribution of labor we see on our projects.

This means that anything that gives front-end people the tools to implement things without needing to wait on coordination with the back-end team multiplies productivity and gives the team a lot more flexibility to tackle more complex projects.

That’s not to say that Loops & Logic is intended to replace PHP developers; we still do plenty of custom PHP development! But now, instead of doing it for basic things like fetching a bit of data, we reserve it for actual new functionality. This allows us to put more effort into true R&D instead of tying up PHP developers with repetitive tasks.

Back-end developers don’t always have the best UI instincts

Another big workflow bottleneck is that often the backend team can create some amazing functionality, but this functionality is only accessible through a sub-par front-end interface. For example, when a developer is deeply focused on building the data architecture of a project, they might not be thinking about the end user’s needs, CSS best practices, or accessibility standards.

By adding L&L into the equation, back-end developers can easily expose the new data structures they’re creating to L&L. That way they don’t have to worry about front-end and UI concerns; they can just make the functionality and let the front-end team have full access to manipulate and display it however they want. Back-end and front-end developers can stick to their areas of expertise without needing to go back and forth.

Small agencies and freelancers don’t have time to become PHP experts

Most WordPress agencies are really small. These companies are often made up of just one jack-of-all-trades and a couple of freelancers helping them out. When a website project requires some back-end development, these individuals don’t have time to learn to code. To make matters worse, getting reliable back-end development help is difficult and if they do find someone, the moment that person is no longer available, the agency can’t effectively continue the work or make sense of what was done or why.

We hear the “just learn PHP” refrain quite a bit in advanced WordPress communities. For people who are already really deep into the PHP world and have years of experience, it all seems obvious and it’s hard to remember what it’s like for beginners just getting their feet wet in the world of PHP development.

Most agencies and WordPress shops are run by generalists whose biggest area of expertise is project management, not development. Once you have a bunch of clients and are already working 10 or more hours per day just to barely keep on top of things, you don’t have hundreds of hours to learn PHP. We’ve spoken to several of these people who often feel guilty because of the many experts in WordPress communities saying things like “just learn PHP,” “it’s so easy,” or “you should know this.”

Everything is easy once you’ve learned it, but these freelancers would have to spend at least 10 hours just to start to understand the very basics of PHP. That wouldn’t be enough to be useful to tackle problems that a client needs solved today and the client can’t afford to wait six months for someone to learn PHP. They’re losing money and opportunities because they don’t know it, but they’ll also lose money and opportunities if they try to pursue it instead of keeping projects moving.

With L&L on the other hand, they can start to see immediate results in 10 minutes and get their foot in the door. Some of them even find that using L&L gives them the mental model they need to feel comfortable diving into PHP later.

When PHP development isn’t feasible, the workarounds are often worse

At the moment, Loops & Logic is a small plugin with a niche community of avid users. If you’re reading this, you’re probably an early-adopter type who loves to be on the cutting edge of WordPress development workflows. Or maybe you’re even a PHP developer yourself.

It’s important to remember that a large percentage of the people who call themselves “WordPress developers” are actually just power users of the software, not actual developers. There aren’t enough “real” devs to meet the demand, especially at prices people can afford.

This means that the alternative to Loops & Logic in most cases isn’t to learn PHP but instead to install 10+ plugins to add each little piece of missing functionality. As anyone who has inherited an old WordPress site managed by a non-developer knows, this creates an unmaintainable mess of a site. On the other hand, when people do hire so-called “devs,” the quality varies wildly and is often not much better than taking a quick hop over to StackOverflow (or these days, ChatGPT) and copy-pasting some code they don’t understand into functions.php.

At the end of the day, Loops & Logic isn’t trying to replace PHP, it’s trying to replace all the bad workarounds people use because PHP isn’t a viable option for them.

Loops & Logic is more legible than PHP, which limits code re-work

A lot of small WordPress businesses are completely at the mercy of their more technical collaborators, whether that’s an agency, freelancers, or internal staff. The client-facing decision-makers often have no way to evaluate whether the claims a developer makes are true and whether they’re doing good work. If a developer leaves, things generally go one of two ways. In many cases, a new developer will tell the project’s decision-maker that the previous developer was rubbish and did it all wrong and it has to be redone. In other cases, the new developer will need to spend a lot of time getting into context before they can pick up from where the previous developer or team left off.

How do we know? Because we’ve inherited our fair share of projects from other developers. It takes one to know one!

Loops & Logic is designed to be extremely legible so that someone with basic HTML knowledge can read it for the first time and have a general idea of what the template is doing and how they could tweak it. Even if you rely on someone else to write an L&L template, just about anyone else on the team can make small edits without fear and understand what was done. It opens up the black box.

The L&L-powered Tangible Blocks plugin improves client handoff

One thing we’ve found that tends to be more of a focus for our agency than other shops is client handoff. We work on sites where there are typically many people on the client team managing the site, sometimes including other developers, who all need to be able to make quick changes to the layouts we create.

The beta version of Tangible Blocks, which uses the same simple language as Loops & Logic in order to build blocks, allows us to create easy-to-edit page builder blocks for all the advanced components of a site. This gives clients the ability to re-arrange everything as they please with no fear of breaking a page’s design or functionality.

At a certain scale, it becomes increasingly problematic that someone working on content can potentially destroy your design system because they have a little too much power. How many times do we as service providers complain that the client messed up our pristine designs after handoff? Tangible Blocks allows people with any level of development experience to make blocks that only include specific required client-facing controls. These blocks also inherit all styling and context from the site so people working on the site can make all the content changes they want without making a mess or breaking the design.

Before Tangible Blocks, we used to have to get a back-end developer to make configurable blocks for these clients. To accomplish that objective, we found that even an experienced dev could take dozens of hours (maybe 50 on average) to create a really good page builder block to hand off some advanced functionality to a client.

We recently invited someone who was new to the L&L templating language to build an equivalent block in our system. Incredibly, they were able to match the functionality in an hour. Except since Tangible Blocks creates universal blocks and not only Gutenberg blocks, their block worked in multiple page builder contexts and was far easier to tweak down the road if the client’s needs changed or if we wanted to repurpose the block for a different client.

Can a PHP developer spend 50 hours making something somewhat better at a technical level than what a less experienced person would make in L&L in an hour? Probably. But we’re sure that clients are far more satisfied with our team getting 50 other things done in that time and fixing their problem the same day instead of over the course of a few weeks.

Developing for WordPress is no longer just about PHP

As WordPress improves Gutenberg and makes its whole platform far more interactive and dynamic, it’s getting a lot more complex to develop WordPress plugins and solutions now that you need more advanced JS/React skills. Luckily, the overall L&L ecosystem abstracts away a lot of that learning curve too.

Our agency works with some of the best developers in the WordPress space, including some that worked at Automattic or on some of the biggest projects and plugins in the space that you probably use. When we ask these developers to work on projects related to Gutenberg or FSE, we’ve often heard them express things like “I’m too old for this!”

Could they “just learn JS/React” on top of their existing advanced PHP knowledge? Of course, these are some of the smartest people on the planet, probably more advanced than almost all WordPress developers. But once you have a full career and you’ve built its foundation on PHP, it gets hard to find the time and energy to pursue new things.

So, which is better: PHP or L&L?

PHP will always have more capabilities than L&L. And this should be obvious, since L&L itself is built on PHP, among other things. But simply having more theoretical capabilities shouldn’t be the deciding factor when establishing which solution to use on a given project.

As the WordPress ecosystem evolves, the amount of knowledge required to complete a complex project on the platform is going up exponentially. While it may not be obvious from the functionality available in the currently released version of L&L, the plugin’s underlying architecture provides a layer of abstraction over all that complexity that produces massive productivity gains for developers who prioritize getting results for clients, simplifying maintenance, and improving handoff at scale. For most agencies and WordPress businesses, prioritizing those elements is going to lead to drastically more growth and revenue than choosing to work with PHP simply because it technically has more capabilities.

At the end of the day, this isn’t a one-or-the-other decision. It’s about choosing the tools that work best based on the types of projects you work on and the priorities of those projects. Since adopting L&L extensively in our agency, we haven’t stopped relying on PHP development. PHP it’s still there and we still use it. It’s just less productive for us to do so for 80% of cases now that our team works with L&L.

One Comment

  1. Great write-up.

    Declarative HTML isn’t just easier to edit, it’s more portable for support purposes: if someone’s code isn’t working, a savvy L&L developer can edit it, send it back via a messageboard reply (or any other copy-pasteable communication) and have it work, without worrying about the recipient’s template structure or their capacity to organize fragile PHP code – where a single error can break your site.

    Because HTML is more ‘in the front-end,’ it’s more forgiving, errors aren’t fatal, and your functionality is in the markup itself, meaning you don’t have to root through a bunch of theme files to see where to edit it.


Leave a Reply

Your email address will not be published. Required fields are marked *