Looker expands its native visual language
Google Cloud is updating Looker’s visual layer with new native charts, dashboard controls and an open-source skill that allows AI coding agents to build custom visualisations. The skill targets agents including Antigravity, Claude and Codex and works against Looker’s Visualisation API. A user can describe a chart in natural language, have the agent generate the implementation, refine it conversationally and deploy it. The approach reduces the JavaScript barrier without replacing Looker’s governed semantic model.
The broader November rollout adds visual forms intended to make operational changes easier to interpret. KPI tiles can show period comparisons and directional status, while richer charts support relationships and patterns that do not fit a conventional bar or line. Dashboard controls are being refreshed alongside the charts. These are not merely cosmetic changes: a visual can determine whether a user notices an exception, compares the correct periods or understands uncertainty in the underlying measure.
Custom visualisations have historically required a developer who understands both the business question and Looker’s extension interfaces. The new skill packages API knowledge and development steps into instructions an agent can follow. That may shorten the path from an analyst’s sketch to a working component, especially for specialised views such as sunbursts, radar plots or calendar heatmaps. It also makes bespoke code accessible to teams that may not have a dedicated front-end engineer.
A skill turns chart requests into code
Natural-language generation does not guarantee analytical correctness. An agent can faithfully build a misleading chart if the prompt asks for an inappropriate scale, aggregates incompatible measures or hides missing data. Looker’s semantic layer helps by providing governed definitions and permissions, but the visual encoding remains a design decision. Teams should define review criteria covering measure meaning, units, filters, sampling, axis behaviour and the business action the chart is supposed to support.
Generated code creates a supply-chain obligation. Organisations need to know which dependencies the agent introduced, whether the component sends data externally and how it behaves with unexpected values. The skill and generated artefacts should be versioned, reviewed and tested like other application code. Deployment rights should remain separate from generation so an agent cannot move experimental code into an executive dashboard merely because a conversation reached a plausible result.
Semantic governance remains the foundation
Accessibility needs explicit attention. Colour-only signals, dense labels and interaction that depends on a mouse can exclude users or produce poor exported reports. Evaluation should include keyboard navigation, screen-reader text, contrast, responsive behaviour and high-volume datasets. An agent may generate technically valid SVG or JavaScript without understanding the organisation’s accessibility standard. Reusable approved patterns can give it safer components and reduce inconsistent chart behaviour across teams.
Performance is another practical constraint. A complex custom visual can request too much data, perform expensive client-side transformations or block dashboard rendering. Developers should measure query time, payload size, rendering cost and behaviour when filters change rapidly. The best use of an agent is to accelerate a controlled engineering loop: scaffold the component, run tests, inspect the result and optimise with real workloads. A generated chart should not bypass normal dashboard performance budgets.
Generated visuals still need human design review
For data teams, the feature may change how work is divided. Analysts can express the intended story, while agents handle repetitive API and styling code. Engineers can concentrate on reusable standards, security and difficult interactions. That is more valuable than simply reducing headcount for chart development. Faster customisation can also create a proliferation problem, so cataloguing, ownership and deprecation policies are needed to stop dozens of near-identical components becoming permanent maintenance obligations.
Google’s Looker update is a concrete example of agents moving from answering questions to extending enterprise software. Its success will depend on whether generated visuals remain grounded in trusted metrics and pass the same review as manually written code. Used well, the skill can shorten experimentation and let teams communicate specialised data more clearly. Used without governance, it can make misleading or fragile dashboards easier to produce. The semantic foundation and human design judgement remain the decisive controls.
A sensible operating model would maintain an approved internal catalogue of visual components generated or reviewed by the data team. Agents could reuse these patterns before creating something new, inheriting tested accessibility, formatting and performance behaviour. Each component should record its owner, supported Looker version, semantic assumptions and sample data. Automated screenshots and regression tests can detect a broken layout after an API or browser change. This turns the coding skill into a governed development accelerator rather than an unlimited chart generator, preserving the speed benefit while keeping dashboards coherent and supportable over time. Teams should also test exports to PDF and spreadsheets, because a chart that works interactively may become ambiguous when distributed as a static executive report. Stable fallbacks, descriptive labels and documented filter state keep meaning intact outside the original dashboard session.