I. The Invisible Process
For any Taiwanese retailer running both physical and online channels, daily operations tend to look like this: one system for store POS; the official site and app running on a commerce platform like 91APP; Shopee with its own seller backend; ad performance split between Meta's and Google's dashboards; traffic numbers sitting in GA. Each system produces its own daily report, in its own format, with columns that don't line up, and even the same order lands on different dates: the ad platform logs it on the day of the click, the commerce backend on the day of payment. So every company ends up running the same invisible process: someone has to pull the tables, clean them, align them, merge them, and compute the trends before real judgment can begin. And judgment can't wait long: which item to reorder, which campaign to boost, whether to rebalance inventory, every decision has its timing. In fashion womenswear the pressure is tighter still, because the run from a need surfacing to the goods selling through is a short one. When the numbers aren't ready, decisions get made on gut feel, or missed altogether.
Xin Hong International Co., Ltd. operates SO NICE and nice ioi, two Taiwanese womenswear brands serving different customer segments while sharing part of their operations and back-office resources; both have been in this market for years. Stores, the official site, and Shopee each run on separate systems. People there have done the math on what the assembly process costs: four hours a week for a weekly report, three hours a month for a monthly one, seven to eight hours a week tracking sales against ad performance; for a product retrospective, one to two days per cycle just assembling the data, then three more days of analysis. Those are numbers reported by a single department, and every department does the same work. Competitor tracking is the merchandising team's standing assignment: when rivals post new arrivals, someone has to look through them and write them down, one by one.
The pain isn't limited to the people who build the reports. Among the weekly reports departments hand up, one common format is a screenshot of an Excel table pasted into a slide deck; to drill one level deeper, you have to open the source file separately. Every department has its own conventions: where the columns go, what the colors mean, which number counts as the headline, and each report demands its own re-adjustment. This is the stack the general manager reads every week.
II. Why Everyone Ends Up Back in Excel
The industry has a standard answer to scattered, hand-assembled reporting: build upward, a data warehouse plus BI, all the numbers in one place, one picture of the whole company. In practice, the traditional road goes like this: bring in outside consultants, run a round of requirements interviews with every department, then hand the spec to IT to build; two or three months if you're fast, half a year if you're not. The company-wide view, each department's own view, all of it is buildable. The catch is that what gets built is exactly what was discussed at the start, and the questions keep changing: warehousing watches inventory turnover this month and may want returns next month; marketing has been tracking traffic and suddenly wants to know which campaign brought in the customers who repurchase most. Questions surface faster than traditional BI can turn around: one cycle takes months, and by the time the answer ships, the question has moved on. Meanwhile decisions don't stop to wait: what needs reordering, what needs boosting, when the moment comes someone has to call it, with no numbers in hand.
So the same scene plays out at company after company: BI bought, BI live, and the moment a new question lands, everyone exports the raw files and opens Excel to build a pivot table. Excel has the lowest floor: everyone knows it. And the widest freedom: add a column if you want one, calculate it your way, no need to clear anything with anyone first.
The price is the two kinds of pain above. Every new question re-runs the entire opening process, one question per pivot table. That long list of hours the staff reported is exactly how it piles up: no system assembles the company-wide picture, so every department pieces it together table by table. And the calculate-it-your-way freedom means everyone's version comes out a little different: that is where the general manager's weekly stack of mismatched reports comes from.
III. So This Time, Start with the People
That this company was willing to try was no surprise: the past decade shows the pattern, every time it hits a bottleneck, it brings in the right new tool to break it. In 2015 it tied its website, app, and a store-staff commission system together; later it adopted 91APP and Omnichat to merge its online and offline operations; in 2023 it added a WMS and Geek+ autonomous warehouse robots. Lee Yu-hung, the current general manager, took over the family business in 2012 and doubled annual revenue within six years (per a 2019 report in Global Views Monthly). He once laid out his own trade-off plainly in an interview: "An average of 80 points gets you into the top school. But everyone chases the last 20 points, and loses the 80 they should have had." (per a 2018 profile in Mirror Media) The reporter called it his 80-point philosophy: grab what matters, let the rest go. Three adoptions in ten years walked the same road: push the whole exam sheet to 80 first, don't burn out on a single subject.
This time is the same play, except the first three rounds targeted systems and this one targets people: rather than standing up a complete AI system from the outset, first give every person a way of working that gets their own job to 80. The AI he chose was Claude Code.
Claude Code picks up Excel's road and offers the same kind of freedom: the floor for getting it to do something is even lower than Excel's, no pivot tables required, you say what you want; hand it the raw files and it is like adding a column in your own spreadsheet, without having to open a formal request just to test an idea. What this layer is about is how usable the tool is, not how loose the rules are: how data is defined, which version counts as the official number, whoever owned those decisions still owns them. And the two prices Excel charges, it removes. Where every question used to mean redoing the whole routine, you now get it working once, write the method down, and re-run it next time with a sentence. Where everyone's version used to come out different, the written-down version can now be handed to someone else. Hence the approach this time: rather than collecting requirements and queueing for builds, let every person build for themselves.
We at Confluence Partners designed and ran the deployment. The concrete setup: a Claude Team plan, one account per person; Claude Code installed on the work machines; then two Skills connecting the company's calendar and email. A Skill is an instruction manual written for Claude: what a job is, how to do it, which tools it may use. The calendar Skill connects DingTalk, using DingTalk's official open-source release, which mounts into Claude Code on install; the email Skill we wrote ourselves, and it operates the Outlook already on each employee's computer. The two connections never turned into a systems-integration project: no middleware servers, no data migration, no preliminary round of systems development. Once connected, everything runs on the employee's own machine, under the access rights that person already had. Both went live in mid-June and, approved by the client's administrator, have been running since.
The curriculum was built from the client's actual work. Beforehand, both sides inventoried the needs inside each person's daily job, fifty-two items in all, sorted them, and worked backwards into three workshops. The teaching materials were built on the client's own report structures, with simulated figures: practice didn't have to touch the real thing. What you practiced in class was what you would do back at your desk.
The first cohort came from retail operations, marketing, e-commerce, warehousing, the executive office, and IT, not one engineer among them; the general manager was one of the students, present at all three sessions. By the end of the first afternoon, every computer held a working workspace: a fixed folder structure where each person put their projects, their scope of responsibility, the reports they use and the rules for reading them. Calendar and email connect into the same place. Open Claude and it already knows what the week holds and what the numbers look like, because that person put all of it there.
The next workday looked different. You could start the morning by asking which emails need attention and which to answer first, with reply drafts already sketched; which meetings are coming in the next few days, and what each one needs prepared.
IV. Then Three Things Started to Happen
First, the most mechanical stretch of the work got handed over. The two brands' weekly report used to mean a person merging table after table: store and e-commerce sales details, targets, inventory, product master data, membership data, ad performance, each exported from a different system, formats mismatched, columns misaligned, every sheet needing cleanup and alignment before revenue could be checked against targets and compared with the same period last year. Staff put the job at four hours, self-reported. The same workflow, handed to Claude Code and verified on desensitized data rebuilt to the real report structures, ran in twenty minutes. That was proven in the classroom, which shows the approach works; once it meets live data there are exceptions to handle and someone to maintain it, and that work starts back at the desk.
The mechanical stretch could be handed over because the workspace already held everything about the person: which slice they own, which numbers they watch, which rules govern the reading. The merged table comes out scoped to that person's responsibility, weighted toward the numbers they actually track.
The three-plus hours saved became the part of the job that never used to fit. Four hours once went almost entirely to assembly; with the numbers finally pieced together, you could look one or two levels down before handing the report in. Now the time goes to the follow-through: the attainment rate slipped, which channel slipped, which category, which campaign failed to connect? You can keep asking, level after level, and Claude runs the analysis and draws the charts along the way. For the first time, judgment gets more hours than assembly.
Second, the method stays. Once the run worked, the workflow was written up as a Skill, the same kind of thing as the two connectors: which data, what logic, what output format, written down once; after that, one sentence to Claude re-runs the whole routine.
This is different from buying software. Buy software, and the process logic lives inside the vendor's system; what users learn is which screen and which button. Run your methods through it for years, and not one word of them ends up written down in your own hands. A Skill is not an interface. It is a document, copyable, distributable, deployable to the whole team through the Claude Team admin console, held by the company in black and white, and it does not vanish when the person who wrote it goes on leave, changes roles, or resigns.
These Skills are their own writing; writing them is what class taught. When a new need comes up, there is nobody to go find, you write one yourself. The Claude Team console supports admin distribution of Skills, and we delivered a distribution guide explaining how to package personal Skills into deployable form; as the Skills accumulate, that is a next step open to the company. What keeps the capability is the company, not only the first cohort through the classroom.
Third, people who don't write code built tools. They can't program, but nobody knows their own work better: which numbers to watch each day, where the process snags, what their hands are missing. In Claude Code the requirement is spoken and the code is Claude's, so the person who understands the problem and the person who builds it are the same person. Every department produced a tool of its own, each finished as a URL that opens and works: data dashboards, a trend knowledge base, each to its own need, all of them first versions built in class and refined back at the desk. The competitor tracker shows how far they got: rivals' new arrivals used to be someone's page-by-page reading assignment; now a staffer's own tool gathers each week's new items into a self-updating wall every Monday morning.
The tools look like one family because each brand's design system had already been settled at the organizational level, and individuals built freely inside the frame; set them side by side and they don't talk past each other. What matters more is that the tools sit in the hands of the people who do the work: when the angle changes or a dimension needs adding, the person who built it changes it, version after version, until it fits the hand, the same way they used to edit their own spreadsheet.
V. What Remains
What this deployment delivered runs one layer deeper at each step: AI connected into every person's working environment, calendar and email inside their own Claude Code; the weekly-report method written as a Skill, re-runnable in a sentence; and at the deepest layer, the ability to build your own tool and put it live yourself.
The problem at the opening was never just that reports are tedious. Womenswear retail steers itself week by week; every decision races the clock, and the hours judgment needed kept being eaten by assembly. This time the answer was not another system purchase, it started from the people. And the road only became walkable with this generation of tools: Claude Code works on the employee's own computer, reads the real reports, writes code that runs. So every person's job now has a way of working that gets it to eighty: the assembly stretch is written down and can be re-run, and when the question changes, whoever wants to ask can follow it down themselves, without starting from scratch on a new round of requirements or waiting for something to be built. The less time data preparation eats, the more goes to judgment and discussion: the numbers caught up with the questions, and judgment caught up with the timing. What this round leaves behind is a team that builds for itself, and the methods they wrote down.