Speaker 1: Microsoft's generative pages look like the final glorious victory for
Speaker 1: low code. The moment the spreadsheet crowd finally caught up
Speaker 1: to the coders, you typer sentence, press enter, and GPT
Speaker 1: five obediently assembles a working React page that talks to
Speaker 1: data Verse, decorates itself with orange flare, and politely runs
Speaker 1: on first try q applause, confetti, and a brief illusion
Speaker 1: that we've transcended the need for developers entirely. Yes, it
Speaker 1: looks effortless. A user describes a dashboard and within seconds,
Speaker 1: the app agent conjures data grids, filters even export buttons.
Speaker 1: Text becomes React, and because it's built right inside power apps,
Speaker 1: it feels safe, regulated, sandboxed. Like the rest of the platform.
Speaker 1: What could possibly go wrong? Everything that tidy UI hides,
Speaker 1: the quiet click of a lock disengaging the magical instant
Speaker 1: when you whisper edit code and the platform hands you
Speaker 1: the keys plus the entire mortgage. Each regenerated line of
Speaker 1: JSX isn't a convenience, it's a liability. You now own
Speaker 1: a trojan horse dressed in productivity, wheels straight past governance
Speaker 1: and security review. The promise is autonomy. The price is maintenance.
Speaker 1: You didn't hire a developer, you became one, minus the
Speaker 1: salary and version control habits. Here's the absurd part. Someone
Speaker 1: decided that giving citizen makers direct React access was empowerment. Apparently,
Speaker 1: years of runaway Excel macros and untested Power effects formulas
Speaker 1: didn't teach us enough humility. So Microsoft wrapped this chaos
Speaker 1: in pustle branding, stamped it generative AI and declared it progress.
Speaker 1: Generative pages whispered, don't worry, the agent will handle it.
Speaker 1: It won't. The agent rights convincing React not sustainable architecture.
Speaker 1: Every tweak creates divergence from the low code core, the
Speaker 1: same core that once safeguarded you from dependency held NPM,
Speaker 1: drift and patroulette. You think you got a shortcut, What
Speaker 1: you actually got was responsibility, the promise, and the pivot. Officially,
Speaker 1: Microsoft causes a bridge, a seamless link between low code
Speaker 1: convenience and pro code flexibility. In theory, GPT five inside
Speaker 1: power Apps is the final layer of the stack that
Speaker 1: lets business users dream in sentences instead of scripting languages.
Speaker 1: Type built a page that lists internal users with filters
Speaker 1: and a capable AI architect assembles the page automatically, files materialize,
Speaker 1: components wire themselves up, and the illusion of mastery begins.
Speaker 1: But here's where the bridge analogy collapses. This isn't a bridge.
Speaker 1: It's an autopilot that starts rewiring the airplane mid flight.
Speaker 1: You may believe your cruising comfortably between low code and
Speaker 1: custom depth. In fact, the AI quietly tears down the
Speaker 1: cockpit controls and sells you a saldering iron. The intent
Speaker 1: is noble. Microsoft's ecosystem has always danced between citizen makers
Speaker 1: and professional depths. The company wants both populations to coexist,
Speaker 1: sharing ditaverse tables and governance policies generative AI, they argue. Finally,
Speaker 1: levels that divide because now anyone can issue natural language
Speaker 1: commands and get production ready code. Except production ready implies
Speaker 1: someone somewhere will maintain it. And that's the catch. Low
Speaker 1: code worked because it was declarative rules, configurations, and formulas
Speaker 1: that Microsoft's engine could interpret, validate, and patch safely. Type
Speaker 1: a formula wrong and you got a friendly error. Toast
Speaker 1: edit react, you get LINTD errors, broken imports, and a
Speaker 1: vacation into stack overflow threads. Last updated in twenty nineteen,
Speaker 1: This is the moment the promise pivots. The interface still
Speaker 1: looks like power apps, but the guts have left the building.
Speaker 1: Once that edit code button is pressed, your app is
Speaker 1: no longer a managed configuration. Its source code, the platform
Speaker 1: stops enforcing its clean boundaries. Identity, data, access, control, logic,
Speaker 1: styling all become mutable text text. You now have to secure,
Speaker 1: diff and patch yourself. Think of power Apps as a
Speaker 1: managed city. Roads are paved, light synchronized, sanitation handled nightly.
Speaker 1: Everyone builds within zoning laws, so nothing collapses. Now. Picture
Speaker 1: generative pages granting zoning exemptions. Suddenly, backyard skyscrapers sprout besides
Speaker 1: single story homes. Power cables cross sidewalks, and no one
Speaker 1: show who maintains the plumbing. It's freedom, yes, but freedom
Speaker 1: that invites entropy. The cognitive dissonance is spectacular. Marketing says
Speaker 1: anyone can build. Reality says anyone can break, and few
Speaker 1: can fix. This gap between illusion and responsibility is where
Speaker 1: technical debt breeds. Users who thought they'd delegate complexity to
Speaker 1: AI discover they've merely delayed it to next quarter's outage.
Speaker 1: Let's dwell on that anyone can maintain myth. A low
Speaker 1: code page describes what to show a React component, prescribes
Speaker 1: how to show it that, how carries dependencies, state management,
Speaker 1: ACYNC behavior data calls each potential point of failure. A
Speaker 1: citizen deav might no ditaverse schemas, but not the difference
Speaker 1: between a promise chain and an ACYNC A weight. GPT
Speaker 1: five can generate them both, but it won't explain why
Speaker 1: one leak's memory underload. Developers see this and laugh, convinced
Speaker 1: the feature finally elevates them. Now we can extend power
Speaker 1: apps freely. They cheer forgetting that freedom without guardrails produces
Speaker 1: the same technical debt they already drown in every sprint. Ironically,
Speaker 1: Microsoft's attempt to merge low code safety with pro code
Speaker 1: control just hands every participant the other camp's problems, and
Speaker 1: that tiny edit button that's where everything unravels. The break
Speaker 1: why pro code is a debt. The moment you click
Speaker 1: edit code, power Apps stops being your babysitter. That comforting
Speaker 1: declarative shield, the one that prevented you from doing anything catastrophic,
Speaker 1: is gone. You now inhabit pure, your React land, where
Speaker 1: one misplaced bracket can unravel an entire interface. Beneath the
Speaker 1: esthetic continuity, the architecture has switched species. Declarative became imperative.
Speaker 1: Governed became freelance. Predictable became good luck. Technically, what happens
Speaker 1: is simple but devastating. A generative page starts as metadata.
Speaker 1: Microsoft's engine compiles it into components that follow the Power
Speaker 1: Apps runtime. Once you open the code panel, the system
Speaker 1: snapshots that pages generated. REACT wraps it in a thin
Speaker 1: integration layer and tells the platform this file is externally managed.
Speaker 1: Translation Microsoft stops maintaining it. The safety net doesn't tear.
Speaker 1: It's intentionally removed. From here on. The dependencies libraries and
Speaker 1: JSX logic are yours to shepherd security updates your problem.
Speaker 1: Dependency mismatches also yours. When dataverse modifies an endpoint signature,
Speaker 1: your ungoverned code doesn't refractor itself. It just breaks quietly
Speaker 1: at three am on a Sunday, right after you told
Speaker 1: leadership the app was self maintaining. In the original low
Speaker 1: code world, the Power Apps compiler interpreted formulas. It safeguarded
Speaker 1: them with type value permissions and centralized patching. You couldn't
Speaker 1: import a vulnerable library because everything lived inside Microsoft's fenced ecosystem.
Speaker 1: React editing dismantles that fence. What material you I find,
Speaker 1: It'll import straight from NPM. Want to inject a date library,
Speaker 1: chart component or custom avatar renderer, go ahead. Each new
Speaker 1: dependency is a potential malware injection vector with the full
Speaker 1: privileges of your data connection. Essentially, the power platform was
Speaker 1: a carefully managed city grid. Every building page flow table
Speaker 1: built under strict architectural codes, sewers connect, traffic, lights synchronize,
Speaker 1: and every upgrade rolls out citywide. Hitting edit code converts
Speaker 1: your plot of land into an unlicensed construction site. You
Speaker 1: can now extend, patch or repaint your property freely. But
Speaker 1: when the sewage backs up through your basement, city hall
Speaker 1: won't help. Let's visualize the debt that blots quietly. After that.
Speaker 1: First comes the React version drift. Power Apps might upgrade
Speaker 1: its rendering engine to a new React release. Your component
Speaker 1: still targets the old one. Hooks deprecate, life cycle methods, change,
Speaker 1: and suddenly it worked yesterday becomes your daily lament. Then
Speaker 1: come NP dependencies, each with its own patch cycle, security advisories,
Speaker 1: and breaking change schedule. Unless you're actively reading CV reports
Speaker 1: a pastime, no business analyst requested, You're walking blindfolded through
Speaker 1: a minefield of vulnerabilities. Consider data verse schema evolution. Someone
Speaker 1: in it renames a column or alters a relationship. In
Speaker 1: classic low code mode, the run time adjusts automatically. The
Speaker 1: next published rebinds controls to the updated schema. But your
Speaker 1: custom React page doesn't know about those updates. It still
Speaker 1: queries the old field name fails silently and serves empty
Speaker 1: grids while end users file help desk tickets. Then there's
Speaker 1: authentication drift. Managed power apps enforce Microsoft enter permissions automatically.
Speaker 1: Custom React components live outside that enforcement boundary. Forget a
Speaker 1: permission check, and your page might happily render sensitive user
Speaker 1: data to anyone with the link. You didn't merely break functionality,
Speaker 1: You violated compliance. Yet the makers remain blissfully convinced the
Speaker 1: AI will patch things later. Oh, I'll just tell the
Speaker 1: agent to fix it, they say, as though GPT were
Speaker 1: a dependable colleague instead of a stochastic parrot with attention issues.
Speaker 1: Generative AI can rewrite broken code, Yes, it cannot understand
Speaker 1: why it broke. Each regeneration piles obstruction upon abstraction until
Speaker 1: your app resembles a tower built by well intentioned interns
Speaker 1: on red Bull impressive from a far unstable up close,
Speaker 1: here's the quiet irony. Professional developers already fight this debt
Speaker 1: in traditional projects. They use CICD pipelines, linters, dependency scanners,
Speaker 1: and version locks to contain it. Citizen developers, those new
Speaker 1: recruits in productivity, rarely have such discipline. When granted full
Speaker 1: react powers, they create the same debt patterns, but without
Speaker 1: the guardrails, and when the inevitable failure arrives, it inherits
Speaker 1: the mess discovering code written half by humans, half by AI,
Speaker 1: and wholly by negligence. So yes, pro code offers control,
Speaker 1: but control without governance becomes chaos with a keyboard. The
Speaker 1: technical debt isn't hypothetical, it's encoded in the moment responsibility
Speaker 1: shifts from platform to person. Every security patch skipped, every
Speaker 1: dependency left unpinned, every minor API change untested, all accrue interest.
Speaker 1: The cost isn't just rework hours, it's exposure surface. Let's
Speaker 1: follow one practical chain reaction. The maker adds an import
Speaker 1: from material Ui to display avatars harmless. Six months later,
Speaker 1: material Ui releases a patch for a cross side scripting exploit.
Speaker 1: Power apps can't apply it because it's not part of
Speaker 1: their managed run time. Your app remains vulnerable until someone
Speaker 1: remembers which app even included that library. Multiply that across
Speaker 1: dozens of pages, and congratulations, you've federated security through ignorance. Meanwhile,
Speaker 1: AI complacency grows. Makers train themselves to rely on prompts
Speaker 1: rather than comprehension. They stop reading the generated code, assuming
Speaker 1: anything produced by Microsoft's agent must meet Microsoft's standards. It doesn't.
Speaker 1: The agent speaks react fluently but has no notion of
Speaker 1: corporate security baselines. It will happily import outdated packages if
Speaker 1: they satisfy your vague request for nicer buttons. And here's
Speaker 1: the checkmate. Once a page enters code edited status, reverting
Speaker 1: it to pure low code is effectively impossible. The generator
Speaker 1: won't safely reabsorb your modifications. At best, it overrides them.
Speaker 1: At worst, it merges nonsense. You can't undo pro code.
Speaker 1: It's a one way migration from platform governed safety into
Speaker 1: self managed fragility. Sarcastically speaking, congratulations, you just became a
Speaker 1: front end developer without consent. You didn't sign up for
Speaker 1: NPM audits, regression tests, or dependency chains. Yet here you
Speaker 1: are managing them by accident. You traded Microsoft safety net
Speaker 1: for autonomy. You can't afford believing AI would subsidize competence. Spoiler,
Speaker 1: it doesn't. It's not if this breaks, it's which part
Speaker 1: breaks first. Is the proof of collapse. What breaks first?
Speaker 1: Microsoft already knows this is unstable. That's why the new
Speaker 1: code Compare tool exists. It's not innovation, it's insurance. Code
Speaker 1: compare lets you view the before and after of your
Speaker 1: edits and admission that contradictory code states are now expected.
Speaker 1: In the low code world, version control was implicit. The
Speaker 1: platform tracked everything. Now with code Compare, Microsoft politely hands
Speaker 1: you Git without the GitHub, a babysitting feature disguised as empowerment.
Speaker 1: Consider what it reveals. As soon as code compare appears,
Speaker 1: you're no longer using low code. You're debugging. You can
Speaker 1: literally watch the AI regenerate react after your edits, splicing
Speaker 1: its code suggestions beside yours. It's the visual manifestation of
Speaker 1: technical debt. A diff where half the lines are human,
Speaker 1: half are GPT, and none are documented. That's not a workflow,
Speaker 1: that's forensic work. The supposed flexibility of external imports makes
Speaker 1: this worse the moment you bring in something like material Ui.
Speaker 1: You've stepped outside power App's walled garden. Inside, controls are vetted, sandboxed,
Speaker 1: updated alongside data verse Outside. You're trusting strangers on NPM
Speaker 1: to behave The import line looks innocent import avatar from
Speaker 1: at maui material Avatar. But behind that cute syntax lurk
Speaker 1: megabytes of unreviewed dependencies with their own transitive chains and
Speaker 1: potential exploits. One styling component pulls ten subpackages, each pulling
Speaker 1: two more. You now have a dependency tree tall enough
Speaker 1: to shade your compliance officer. And here comes the security bombshell.
Speaker 1: Those libraries don't live in isolation. They run with the
Speaker 1: same privileges as the page, meaning they handle the same
Speaker 1: enterprise data. You just gave unaudited, open source JavaScript access
Speaker 1: to your company's internal directory. Calling that citizen development is
Speaker 1: like letting strangers run electrical wiring in your office because
Speaker 1: they watched one tutorial. It's not merely theory. Style tweaks
Speaker 1: ripple unpredictably. One user changes a table header color, React
Speaker 1: recompiles entire component trees because your modified page divert from
Speaker 1: Microsoft's templates automated patching no longer applies cleanly. The next
Speaker 1: time power apps updates its rendering engine, your styled grid
Speaker 1: becomes a Picasso composition. Columns evaporate, filter's misbehave, and hovering
Speaker 1: over a label triggers existential dread. Then comes the double
Speaker 1: generation problem. Users assume GPT five will respect their manual
Speaker 1: code tweaks when regenerating it doesn't. The agent rewrites with
Speaker 1: cheerful indifference, overwriting some variables, leaving others, producing franken code
Speaker 1: that half works. The brand new code compare view becomes
Speaker 1: a Morgue report, red and green lines, chronicling the slow
Speaker 1: decomposition of one's stable behavior. AI and human fight silently
Speaker 1: over control of the same file, each confident it knows best.
Speaker 1: Imagine a simple change, adding a filter to show only
Speaker 1: enabled users. AI does its rewrite, preserving earlier modifications when possible,
Speaker 1: And somewhere in that vague phrase lies disaster. Perhaps you
Speaker 1: renamed a constant or wrapped lock loic in a new hook.
Speaker 1: GPT doesn't pass intent, It pattern matches strings. The outcome
Speaker 1: is familiar in visible breakage, visible embarrassment. A weekday merges
Speaker 1: into a lost week end of debugging conversationally generated nonsense
Speaker 1: data verse adds its own sabotage via schema, drift tables,
Speaker 1: evolve columns, renamed, relationships restructured. Low code handled those changes automatically.
Speaker 1: Your detached React page doesn't know this evolution happened. It
Speaker 1: still calls user email, but the field became primary email.
Speaker 1: The result empty grids, silent errors, chaos disguise as functionality,
Speaker 1: and because the bug isn't syntax level, nothing crashes. The
Speaker 1: page just lies convincingly. Upgrading power apps once meant excitement.
Speaker 1: Now it's Russian roulette. Each new release could obsolete one
Speaker 1: of your imports or break a binding that AI invented
Speaker 1: months ago. The only way to test safety is to
Speaker 1: open code, compare, and pray there's nothing read. Some organizations
Speaker 1: already lock environments to frozen versions, trading progress for survival. Congratulations,
Speaker 1: you've recreated legacy SharePoint customization. But shinier. Here's where the
Speaker 1: humor kurdles. Microsoft build generated pages to accelerate development, but
Speaker 1: quietly equipped power apps with code forensics instead of new features.
Speaker 1: That's not confidence, that's crisis management. When a platform invents
Speaker 1: tools for diffing your creative freedom, it's admitting loss of control.
Speaker 1: Even styling choices become volatility engines. Remember that lighter orange
Speaker 1: grid stripe. Each color hex you replace can trigger cascading
Speaker 1: diffs through CSS. In JS bindings, one user's vanity change
Speaker 1: becomes another's runtime error. The new orange theme might compile
Speaker 1: locally but fail in production because the updated material u
Speaker 1: I theme no longer exposes that variable. This isn't creative expression.
Speaker 1: Its artisanal chaos at scale. And let's not ignore patch roulette.
Speaker 1: The moment a data verse or entra update collides with
Speaker 1: your ungoverned logic role based access change slightly, your hard
Speaker 1: coded condition still assumes the old object path. Now half
Speaker 1: your users can't load the page and the other half
Speaker 1: can see everyone's data. Fixing it requires pouring over AI
Speaker 1: generated conditionals that nobody wrote intentionally. Collectively, these failures reveal
Speaker 1: the fundamental truth. The low code safety net isn't broken.
Speaker 1: It's gone. The guarded runtime that once insulated you from
Speaker 1: open source entropy has been replaced with privileged escalation on demand.
Speaker 1: You used to build within a secure toy box, Now
Speaker 1: you've been handed a chainsaw with a smiley sticker. At
Speaker 1: this point, prevention is fantasy. The architecture encourages divergence faster
Speaker 1: than governance can respond. Microsoft's patching schedule can't account for
Speaker 1: thousands of citizen altered react branches, each mutating independently like
Speaker 1: digital species. The code compare feature isn't a safeguard, it's
Speaker 1: an archaeological tool for future incident response. So the next
Speaker 1: time an enthusiastic manager asks if generative pages empower the business,
Speaker 1: answer carefully yes, they empower it to inherit unbounded liability.
Speaker 1: The glamour of AI coded freedom conceals a maintenance nightmare
Speaker 1: where every grid, color and import might detonate tomorrow. At
Speaker 1: this point, prevention is impossible. Only containment remains, containing the
Speaker 1: chaos governance in a post low code world. Let's be pragmatic.
Speaker 1: The horse has left the stable, burned the barn, and
Speaker 1: is currently generating JSX in your production environment. Rolling back
Speaker 1: generative pages isn't an option. Managing their fallout is. Microsoft
Speaker 1: won't revoke the feature. It's too shiny for marketing to surrender,
Speaker 1: So governance must adapt from prevent to contain the new
Speaker 1: Discipline isn't about stopping chaos, it's about quarantining it. Containment
Speaker 1: starts with three rules. Isolate, review, restrict think of them
Speaker 1: as bio hazard procedures for code exposure. Rule one isolate
Speaker 1: and elevate. The moment a maker clicks edit code, that
Speaker 1: app ceases to be a low code artifact. It's now
Speaker 1: a software project and must live in a developer environment.
Speaker 1: With proper life cycle management, you wouldn't store a radioactive
Speaker 1: isotope in the breakroom. Don't let edited react pages sit
Speaker 1: in the same tenant as citizen apps. Move them to
Speaker 1: a pro dev workspace where visual designers fear to tread,
Speaker 1: attach version control, and track dependencies like adults. Low code
Speaker 1: governance tools can't validate dependencies or run unit tests, but
Speaker 1: DevOps pipelines can. Elevating contaminated apps isn't punishment, it's cleanup.
Speaker 1: Rule two review gate. Every modified page, whether changed by
Speaker 1: a human or the AI agent, needs continuous inspections. Establish
Speaker 1: an approval gate that mimics enterprise CIICD, run eres lint,
Speaker 1: dependency scanners, and static code analysers before republishing. If that
Speaker 1: sounds excessive for citizen development, good that means you remember
Speaker 1: what discipline looks like. Microsoft's own update cadence will collide
Speaker 1: with your code eventually. Linting infrastructure gives you a fighting
Speaker 1: chance to notice before users do. Remember if everything compare
Speaker 1: not just for syntax, but for intent. An unreviewed AI
Speaker 1: patch is indistinguishable from a supply chain exploit. Rule three
Speaker 1: one way door policy. Once code is edited, it never
Speaker 1: returns to the garden. No regenerating it back into declarative metadata.
Speaker 1: No just undoing the pro code status. Lock the file
Speaker 1: and taget as independently maintained. This establishes accountability. When it breaks,
Speaker 1: and it will, you'll already know who owns the problem.
Speaker 1: It's the digital equivalent of labeling your lunch in the
Speaker 1: office fridge to avoid mysterious disappearances. These three rules don't
Speaker 1: restore purity, but they define boundaries in a hybrid ecosystem
Speaker 1: that's lost them. Treat every generative page as a separate species,
Speaker 1: requiring controlled habitat. Pro def environments become fenced preserves where
Speaker 1: mutated apps can evolve without infecting your stable population of
Speaker 1: classic power apps. Its evolutionary containment via environment segmentation, a
Speaker 1: concept familiar to anyone managing cloud tenants or frankly zoo exhibits.
Speaker 1: Now to the cultural problem. Business users still believe code
Speaker 1: editing equals empowerment. Disabuse them gently but firmly. Governance is maturity,
Speaker 1: not micromanagement. Enforcing reviews and segregating edited apps doesn't cage creativity.
Speaker 1: It saves continuity. The irony of low codes evolution is
Speaker 1: that it brings enterprises full circle back to software engineering fundamentals.
Speaker 1: They once escaped, version control, least privileged, code review, old
Speaker 1: rituals reborn under pastel ux. And remember the sarcasm baked
Speaker 1: into this transformation. You clicked edit code, Congratulations, you own
Speaker 1: it now. Ownership means maintenance, monitoring, patching, documentation, the boring
Speaker 1: work necessary to keep lights on. Pretending otherwise just ensures overtime. Later,
Speaker 1: what once felt like spontaneous automation now demands structured operations.
Speaker 1: That's not failure, that's recognition of scale. Still, this shift
Speaker 1: is worth something valuable. When governance catches up, organizations gain
Speaker 1: a bifurcated ecosystem that reflects reality instead of fantasy. Low
Speaker 1: code site delivers agility for safe configurations. The pro code branch,
Speaker 1: fenced and audited handles customization beyond Microsoft's reach. The chaos
Speaker 1: becomes predictable. The liabilities mapped. That's the maturity arc of
Speaker 1: all technology. Exuberant adoption painful consequences. Then, principled governance. Power
Speaker 1: apps isn't dying, it's being reclassified. What was once no
Speaker 1: code now spans from descriptive to imperative, from playground to
Speaker 1: factory flaw. Enterprises that adapt policy faster than makers break
Speaker 1: features will survive this generative adolescence with minimal scarring. Those
Speaker 1: who don't will discover what technical debt feels like when
Speaker 1: multiplied by AI enthusiasm. Because this isn't the death of
Speaker 1: power apps, it's its reclassification. The reality Microsoft created generative
Speaker 1: pages didn't enhance power apps. They dismantled its illusion of safety.
Speaker 1: By bridging low code and pro code, Microsoft accidentally vaporized
Speaker 1: the border that kept novice makers from detonating production environments.
Speaker 1: The result is a platform where every prompt can generate
Speaker 1: beauty or liability at scale. The grand moral power without
Speaker 1: governance breeds breakage. Microsoft democratized innovation, yes, but it also
Speaker 1: democratized the blast radius. Click edit code and you inherit
Speaker 1: the complexity entire teams once handled. Locode wasn't built to
Speaker 1: carry that weight yet Now every user drags it behind
Speaker 1: their prompts like a forgotten anchor. So treat every new
Speaker 1: feature less like magic and more like chemistry. Powerful volatile
Speaker 1: requiring goggles. Adopt containment policies, automate reviews, label ownership, or
Speaker 1: prepare for the next AI written patch to helpfully rewrite
Speaker 1: your security posture or worse your job description. If this
Speaker 1: clarified the mess, repay the sanity, subscribe, turn on notifications
Speaker 1: before GBT six releases and starts generating governance policies on
Speaker 1: your behalf. Better to learn them here first, voluntarily