Creating an Adaptive Code

Today’s post is a bit wonkier than usual, intended to invite discussion from my zoning nerd friends. If that’s not your jam, feel free to skip this one.

On a personal note, I’ll be attending Progress Conference next week, and I hope to run into some of you there!

At Strong Towns, we’ve offered a simple principle for healthy land use policy: “No neighborhood can be exempt from change, and no neighborhood should experience sudden, radical change.” Adaptive Code is my proposed alternative to zoning that aims to get us there.

I’ve previously explained the core concept, and illustrated what an Adaptive Code might look like in Denver. Today I want to dig a little deeper into what makes a code Adaptive, and how it might get adopted.

As a brief recap, there are two big differences between Adaptive Code and conventional zoning:

1. What you can build on a lot is determined by the surrounding conditions, not a zoning map.
2. The rules allow properties to incrementally “step up” to a higher level of development by right.

In order to actually achieve that, an Adaptive Code must have two elements: Step Definitions, and a Succession Function.

Step Definitions

In an Adaptive Code, Step Definitions are essentially the alternative to zoning districts. They define levels of development that a property can pass through over generations as a place evolves. For example, when historic cites grew we’d typically see an evolution from smaller houses to larger, multi-unit houses, to things like row houses and apartments.

Step Definitions are easiest to understand by example. To illustrate, here’s a simplified concept I pulled from elements of Denver’s existing zoning code, defining six sequential levels of development:

The idea of defining “levels of development” is similar to Japanese Zoning, in that we’re describing broad, permissive categories of development rather than narrow, single-use zones. There’s an implicit progression from lower to higher levels of development in Japanese Zoning, but in Adaptive Code we make that sequence explicit (aka, we’re defining a Transect).

Succession Function

The whole point of an Adaptive Code is to allow places to evolve over time. Thus, the most important element of the Adaptive Code is the Succession Function. The succession function is an equation where you put in “what’s there now” and you get back “what you can build by right.”

The simplest succession function is that every parcel can always go up one level. In other words, the equation might look like this:

Allowed Level = Current Level + 1.

The formula must be deterministic. The whole point here is that you can “step up by right.” There’s no rezoning, you don’t need variances. Instead, the reality on the ground determines what you what you can do next.

Calibrating the Code

Given the abstract idea of Step Definitions and a Succession Function, we have to actually define steps and how properties are allowed to step up. In Smart Code they call this step “calibration” — taking the template and putting in real values for a particular place.

The most important part is to define steps of the right size. If the step up from one level to the next is too small, then it won’t be economically viable for property owners or developers to add housing units when they’re in demand. On the other hand, if the step up from one level to the next is too big, it incentivizes speculation and hold-outs, which can actually make the neighborhood less responsive to local housing needs.

Then we have to define a deterministic succession function. I think the function should be relatively simple, but I also think the context around a lot has to be part of the equation.

To illustrate why, suppose you had a vacant lot surrounded by mostly “level one” lots but a couple that had stepped up to “level two.”

The baseline rule of “you can go up one” suggests you should be able to build that lot up to “level two,” and the result seems like common sense. The neighborhood is gradually evolving from level one to level two. But what if that same vacant lot was entirely surrounded by a higher level of development?

In that case, the neighborhood is all “level two” already, so the next step is arguably “level three,” even though the vacant lot itself is “level one.” This problem becomes more glaring if you think about a lot in a more developed area. Suppose that your town’s Main Street development is already “level three”…

It doesn’t make sense to say that a vacant lot there is limited to “level one.” In fact, we wouldn’t want to say that, in an area that’s already this built up, the vacant lot can only be something much smaller and less mature than the surrounding context. We want that lot to catch up! So, at minimum it should be allowed to “skip” up to “level three,” and it probably should be allowed to step up to “level four,” which is the next logical step for the neighborhood.

To solve for this problem, the input into the Succession Function has to include some surrounding context. Ie, we need to take some number of surrounding lots, or some distance around your lot, into consideration. Perhaps you take the adjacent five lots (as I did in the illustrations above), and the rule is that your lot can step up to the average level of those lots plus one level.

Paths to adoption

I don’t think there will be a perfect one-size-fits-all set of step definitions that could or should be adopted everywhere. It seems likely that cities would benefit economically from having “custom-calibrated” code that addresses the particular quirks of their place. So, that would be an argument for each city to create their own code and change it over time to figure out what works.

At the same time, I think that asking every city to invent their own adaptive code from scratch is an unrealistic demand on limited staff capacity, and that makes it unlikely that most cities would adopt something like this at all. That would be an argument to adopt a code at the state level and just have cities administer it.

But history shows us that technocrats creating rules in a vacuum, based on what sounds nice to them in theory, doesn’t go very well. In fact, that’s how the high modernists got us into the messes of parking requirements, stroads, and euclidean zoning in the first place! So I’m not keen on cooking this up in a lab and then having states push it down.

What I’d ideally like to see is some pioneering cities (or even neighborhoods) try to make their development code adaptive. As we test and learn, the best outcome might be to develop multiple codes that would, in a sense, “compete” for adoption. Some could be aimed at small towns, others aimed at outer or inner-ring suburbs, others at landlocked central cities. And in some cases, cities that have capacity could create their own custom-calibrated code.

Having multiple alternatives “compete” for adoption means we’ll have more experimentation and more learning. It also seems likely to me that we’ll discover “best practice” that works well in 80% of cases, and codes will converge. But I think it would be better to bake that exploration, iteration and evolution into the code adoption process, rather than try to have some centralized authority push a new, untested code from the top down.

Where I think states could lead is in setting the expectation in the first place: no neighborhood can be exempt from change, but no neighborhood should experience sudden, radical change. So, your local development code needs to define levels of development (step definitions), and a by-right process for lots to step up (succession function). Perhaps states could certify codes that meet this requirement, and cities could pick a certified code to adopt, or create their own and get it certified.

Thanks for reading! If you’d like to support my work, please consider sharing it with others.

A side note for people who have followed this idea over time. At first I didn’t think we should have pre-determined steps. Instead, I thought the code should be “parameterized,” meaning the details about lot size, coverage, setbacks, etc. should be independently determined by matching the surrounding development and then adding a step up. Over time I’ve shifted away from that, as I think it’s a much bigger leap from how things work today, and may be too complex to administer effectively.

Kudos to my friend who recently suggested this idea in the context of building codes.