
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The Coming Surge in Power Demand - Could Trump upset the cart?</h3><h4>14 November 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>As President, I will set a national goal of ensuring that America has the #1 lowest cost of energy of any industrial country anywhere on Earth. We will not only match China. We will be cheaper than China by a lot. And more energy will mean lower inflation that will mean more jobs<em>"</em></p><p>Donald Trump</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-coming-surge-in-power-demand' href='/Content/Downloads/ARP/ARP241114.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/6717c31219fcbae3b52d9a94_iStock-1401292297_705x414.jpg#251;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: US electricity generation, kTWh </strong><br />
<em>Sources: IEA, WEO, Bloomberg</em></p>
' data-image='/Content/Images/67361b5f5cf7e4d60f9a9fb7_673619eae893e07e2309c604_Picture1.png#301;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#301;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#301;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#301;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The era of electricity</h4><p>In his election campaign, Donald Trump made many promises, one of which was to deliver cheaper energy to the Americans than any other industrialised nation is capable of. Whilst making that promise, he didn&rsquo;t specify what sort of energy he was referring to, but his remarks raised a couple of questions in the back of my head. If we are about to enter the era of electricity (and we are &ndash; see Exhibit 1):</p>

<p>1. can he actually deliver on his promise? <em>and </em></p>

<p>2. if he struggles, could the ongoing process to electrify &lsquo;everything&rsquo; be affected, for example by &lsquo;going back&rsquo; to fossil fuels?</p>

<p>--image--</p>

<p>Some may question my line of questioning here, partially because fossil fuels are still widely used &ndash; i.e. all this talk about phasing them out probably sounds quite hollow in many ears &ndash; and partially because the use of one energy source (fossil fuels) doesn&rsquo;t preclude another one (electrification) from growing in importance.</p>

<p>For a very simple reason, Trump is up against difficult odds, if his aim really is to go back to oil &amp; gas, and the reason is that he has no power over the 50 states in the Union when it comes to controlling GHG emissions. Allow me to explain.</p>

<p>The US confederation is a union of 50 quasi-independent states which maintain control over certain matters. Take for example the carbon allowance programme in California. In his previous presidency (2017-20), his administration challenged the state of California in court, arguing that putting rules and regulations in place to manage GHG emissions was a federal matter. The Trump administration lost the case.</p>

<p>In other words, what various states decide to do to address the rapidly growing climate crisis, he can do little to change. According to OECD, about one-third of all GHG emissions in the US are now subject to a carbon allowance scheme of some sort, and that number grows every year. Therefore, it shouldn&rsquo;t really come as a surprise that more and more functions will be electrified.</p>

<p>One could then start a discussion as to how the electricity has been generated, and if the answer is by burning fossil fuels, little has been achieved, but let&rsquo;s leave that discussion for another day and simply assume that increased electrification means lower GHG emissions.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: US electricity generation by source, 1990-2021 (%) </strong><br />
<em>Sources: IEA, NPUC</em></p>
' data-image='/Content/Images/67361b5f5cf7e4d60f9a9fb4_67361a6eaaa578e029f6fc70_Picture2.png#302;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#302;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#302;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#302;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The underlying problem </h4><p>GHG emissions won&rsquo;t drop just because you electrify &lsquo;everything&rsquo;, if fossil fuels continue to be used to generate the electricity required. As you can see in Exhibit 2 below, although the use of coal in the US has more than halved over the last 35 years, coal and natural gas combined account for about the same as they did in 1990.</p>

<p>Although gas is less polluting than coal, it is still much far more polluting than wind, solar and nuclear energy. In other words, electrification on itself won&rsquo;t fix any problems. It depends on how the electricity is generated.</p>

<p>--image--</p>

<p>&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#303;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#303;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#303;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#303;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Various new technologies</h4><p>Is there anything on the horizon which could save Trump&rsquo;s bacon, so to speak? The short answer is &ldquo;no&rdquo;. The slightly more elaborate answer is that there is indeed plenty of new technologies on the horizon but:</p>

<p>1. most of them are unlikely to be commercialised during his presidency; and</p>

<p>2. none of them are cheaper than fossil fuels &ndash; at least not in the early days.</p>

<p>In no particular order, I can think of small modular reactors (the nuclear power industry&rsquo;s next generation of fission reactors), fusion reactors, green hydrogen, white hydrogen, geothermal energy and better (longer-duration) grid batteries, which should allow for more wind and solar energy to be used in power stations.</p>

<p>I have keenly followed the debate about the need for more powerful grid-scale batteries. Na&iuml;ve politicians (na&iuml;ve &ndash; at least in Europe) argue that we should fully convert to renewable energy forms ASAP, plainly ignoring the fact that, today, the most powerful grid-scale batteries can only keep a country running for 1-2 hours, if there is a total blackout.</p>

<p>And that <em>will</em> happen from time to time if nearly 100% of our energy supply comes from wind and/or solar. As we know only too well here in northern Europe, the sun doesn&rsquo;t always shine, and the wind doesn&rsquo;t always blow.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#304;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#304;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#304;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#304;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>If there is no easy fix, what can we (Trump) do?</h4><p>Trump is facing the ultimate dilemma here, assuming he wants to deliver on his promise to grow the US economy fast with cheap energy. There is only one source of (relatively) cheap energy today and that is fossil fuels.</p>

<p>However, an increased use of fossil fuels will lead to higher GHG emissions, and many of those who burn those fossil fuels will be financially penalised under the carbon allowance scheme in operation. In turn, the financial penalty (which he can do little about) will absorb capital that could otherwise have been used to invest, i.e., to grow faster. Therefore, a promise to deliver cheap energy to grow faster is an <em>impossible </em>promise in today&rsquo;s environment.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#305;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#305;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#305;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#305;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>For now, green stocks are out of favour. Investors have taken the rather simplified view that green stocks will be a bad investment under Trump and, in the near-term, I would agree; however, as pointed out above, certain green policies are beyond his control, and there will come a day when there is a lot of money to be made on green stocks. You need to let the dust settle first, though.</p>

<p>The Californian carbon allowance scheme is the most developed carbon allowance scheme in the US, and one option would be to go long those contracts (we already are).</p>

<p>Another option would be to go long certain types of green stocks that are likely to benefit from the higher tariffs on China that Trump is about to introduce. If you follow the US market as keenly as I do, you will have noted that US auto companies have been amongst the best performing industries since Election Day. Something similar is likely to happen to certain green industries, for example solar, once the dust has settled.</p>

<p>A third option would be to look to Europe and Asia for opportunities. Green stocks have also suffered there, even if they are not directly affected by a change in the American green policy programme. The commitment to the green transition in both Brussels and Tokyo remains intact, but green stocks have still suffered there in sympathy with recent developments in the US.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>14 November 2024</strong></p></div></div></div>