Techlist.io - Korean Tech Blog Curator

toss4 min readCurated summary

Designing the Work You Do Every Day

A product designer at Toss Bank transformed her personal task-management routine instead of accepting repetitive manual work as unavoidable. She built an AI-powered desktop widget that collects Slack messages, summarizes them into actionable tasks, preserves their context, and helps her focus on prioritization. What began as a personal solution revealed a broader problem shared across roles and spread throughout her team. ## From Manual Task Tracking to Workflow Design - For two and a half years, she manually copied tasks, feedback, discussion links, and requests from Slack into Notion or Slack lists. - As her responsibilities expanded to three teams, daily tasks grew from roughly 10 to more than 20. - She reframed the issue as a product-design problem: - **User:** herself - **Real goal:** completing the most important work without missing anything - **Main friction:** copying, organizing, and locating context - **Ideal state:** tasks collected automatically, leaving only prioritization to manage - This led to three core requirements: - AI should register tasks directly from Slack. - Each task should retain its source thread and document links. - Priorities should remain visible in an always-present widget. ## Teaching AI to Understand Work Context - Adding a specific emoji to a Slack message sends it to a designated channel. - Claude Code reads the message and converts it into a task with: - A concise summary - The relevant team tag - A link to the original Slack thread - The hardest part was turning long, contextual Slack conversations into one clear action. - For example, a request about an error during a loan-extension application becomes “Check loan-extension error case.” - She created writing guidelines and examples defining: - What qualifies as a good task - How teams should be categorized - Which expressions and sentence structures to use - The goal was for AI-generated tasks to sound like something she would have written herself. - Refining the AI’s output was less about coding than encoding her judgment about what constitutes a real task. ## Designing the Widget Experience - Making the widget feel natural required detailed interaction design and repeated implementation. - She rebuilt the code to refine the expand-and-collapse behavior. - The drag interaction took nearly a week to complete. - Explaining seemingly obvious behaviors to AI forced her to define her own requirements more precisely. - In this sense, working with AI became a process of clarifying thoughts and translating them into explicit language. ## Replacing Anxiety with Prioritization - She no longer needs to open Slack or Notion repeatedly to remember her tasks. - The always-visible widget removed a previously unnoticed source of friction. - AI now handles collecting and organizing work, reducing the mental energy spent on administration. - She can concentrate on deciding what matters most instead of worrying that something has been forgotten. ## A Personal Problem Shared by the Team - Although the widget was initially built for personal use, many colleagues adopted it. - Developers unexpectedly became active users, reporting bugs and suggesting features. - The usual designer–developer relationship reversed: developers raised issues while she fixed and redeployed the tool. - This showed that task collection, prioritization, and context management are common problems across job functions. - The tool spread not because its concept was revolutionary, but because it addressed an existing, widely felt inconvenience. ## Applying the Method - Identify the most frequent “not really work” task from the past week: - Copying information - Searching for context - Organizing lists - Define the problem as a product: - Who is the user? - What are they truly trying to accomplish? - Where is the greatest friction? - What does success look like? - Examine why existing tools do not solve the problem. - Start with the smallest version that can be useful immediately. The practical lesson is to treat repetitive coordination work as something that can be designed away. Instead of searching for a perfect general-purpose tool, build a small solution around the specific context, habits, and judgments that existing products cannot know.

Read original(opens in new tab)
gitlab1 min readCurated summary

GitLab and Capgemini accelerate DevSecOps transformation

GitLab and Capgemini have formed a global alliance to help organizations modernize software delivery and adopt secure, AI-assisted development practices. Capgemini will provide GitLab’s DevSecOps platform, including GitLab Duo Agent Platform, alongside implementation and transformation services. The partnership aims to shorten the journey from platform adoption to measurable business results. ## Partnership and Client Benefits - Capgemini becomes a GitLab Select Partner serving clients globally. - Customers receive expert guidance on tools, processes, and transformation methodologies. - GitLab Duo Agent Platform will help orchestrate AI across the software development lifecycle. - The combined offering is designed to accelerate delivery while improving software supply-chain security. ## Initial Areas of Focus - **Cloud-native development and application modernization:** Moving legacy workloads to modern architectures. - **Sovereign solution design and delivery:** Addressing regulatory, regional, and data-residency requirements. - **Value stream modernization:** Improving the path from initial idea through production release. - **Generative and agentic AI:** Integrating GitLab Duo Agent Platform into development workflows to help teams ship faster. Organizations interested in the alliance’s services can contact GitLab or Capgemini representatives.

Read original(opens in new tab)
figma3 min readCurated summary

Speaking the Language of Color | Figma Blog

Color is presented as a cultural language that influences emotions, perception, branding, and consumer behavior. The Pantone Color Institute studies these associations through psychology and trend forecasting, helping organizations choose colors that communicate specific messages. Effective color decisions require cultural awareness, a clear brand purpose, and consideration of the physical or digital medium where the color will appear. ## How Colors Influence Perception - Color associations often arise from nature: - Yellow suggests sunlight, warmth, and joy. - Green implies renewal and growth. - Brown conveys groundedness. - Blue is associated with dependability and stability. - Orange recalls fruit and tangy sweetness. - Cultural trends also shape color preferences, including: - Film, art, travel, sports, and technology. - Lifestyle changes and broader social conditions. - Economic pressures, which can cause palettes to shift. - Color meanings vary by region: - Black is associated with mourning in much of the West, while white serves that role in parts of the East. - Red can suggest love, anger, or urgency in Western contexts, but luck and prosperity in Eastern cultures. - Brands should research local color sensibilities rather than assume that a trend has universal meaning. ## Building a Brand Story Through Color - Strong brand palettes express what a company stands for and support its broader narrative. - Coca-Cola’s red communicates energy and excitement and has become inseparable from the brand. - Airbnb’s 2014 shift from baby blue to salmon pink was intended to convey warmth, humanity, comfort, and connection—qualities that supported its expansion into local Experiences. - “Brat Green,” associated with Charli XCX’s 2024 album, illustrates how an unconventional color can capture attention and reflect cultural attitudes: - Its yellow undertone adds energy and vitality. - Its organic associations suggest authenticity amid increasing digital saturation. - Its unusual appearance helps it stand out on social media. - Pantone’s own Config palette combines bright, pastel, earthy, aquatic, and nature-inspired colors to connect the physical and digital worlds. ## Designing for Materials and Surfaces - Colors do not appear identically across screens, fabrics, packaging, or other physical materials. - A color that looks appealing digitally may seem overly harsh in person. - Some hues achievable in fabric dyes may not be practical for products made from other materials. - Color decisions should therefore begin early in the design process, with the material, surface finish, and viewing context already considered. ## Tracking Cultural Change - Pantone’s Color of the Year program has run for more than 26 years and is one of the design industry’s most closely watched color forecasts. - The institute’s broader work combines color psychology, global observation, and trend forecasting to identify how cultural shifts influence color preferences. The practical recommendation is to treat color as a strategic design decision: define the intended message, understand the audience’s cultural associations, and test the color in its actual material and environmental context.

Read original(opens in new tab)
aws3 min readCurated summary

Amazon S3 annotations: attach rich, queryable context directly to your objects | Amazon Web Services

Amazon S3 annotations let organizations attach rich, mutable context directly to objects without rewriting the underlying data. Each object can have up to 1,000 named annotations, with a combined limit of 1 GB, in formats such as JSON, XML, YAML, or plain text. The annotations move with objects during copying and replication, can be queried through S3 Metadata tables, and are intended to support large-scale analytics and AI-driven workflows. ## Richer Metadata at Object Scale - Annotations address limitations of existing S3 metadata features: - System metadata describes properties such as size and storage class. - Object tags support operational tasks but are limited to 10 immutable tags. - User-defined metadata is limited to approximately 2 KB of headers and must be supplied during upload. - Annotations can be modified or deleted independently without rewriting the object. - Each annotation has a unique name and can hold up to 1 MB, with up to 1 GB total per object. - Supported content includes structured formats such as JSON, XML, and YAML, as well as plain text. ## Supporting AI and Industry Workflows - AI-generated transcripts, summaries, classifications, ratings, and technical specifications can remain attached to the relevant data. - Media companies can store transcripts, moderation results, subtitles, licensing information, and media specifications alongside video assets. - Financial institutions can attach investment summaries and sentiment analysis to research documents for autonomous discovery. - Life sciences organizations can add regulatory status, cohort information, and approval chains to clinical-trial data. - Annotations remain available for objects in archival storage classes without restoring the objects or paying retrieval charges. ## Object Lifecycle and Synchronization - Annotations automatically move with objects during copy, replication, and cross-Region transfers. - S3 removes annotations when the associated object is deleted. - This reduces dependence on separate metadata databases or sidecar files and avoids synchronization overhead. - Different teams or enrichment processes can maintain separate annotations on the same object without overwriting one another. ## Working with Annotations - IAM or bucket policies must grant: - `s3:PutObjectAnnotation` - `s3:GetObjectAnnotation` - The main APIs are: - `PutObjectAnnotation` to create or update an annotation - `GetObjectAnnotation` to retrieve one annotation - `ListObjectAnnotations` to view all annotations on an object - `DeleteObjectAnnotation` to remove an annotation - Reusing an annotation name with `PutObjectAnnotation` updates its content. - For multipart uploads, annotations are added after the upload is completed. - The example uses separate `mediainfo` JSON and `ai_summary` text annotations on a video object. ## Querying Through S3 Metadata - When S3 Metadata is enabled, annotations automatically populate managed annotation tables. - These tables can be queried with Amazon Athena and other analytics engines. - The S3 Tables MCP server provides a standardized interface for AI models and agents to query annotation data using natural-language workflows. - This enables discovery across large collections of S3 objects without retrieving the objects themselves. S3 annotations are most useful when object context is large, frequently updated, and needed for cross-object search or AI automation. Organizations should use them to keep business and machine-generated metadata directly associated with the data while using S3 Metadata tables for scalable querying.

Read original(opens in new tab)
github2 min readCurated summary

What are git worktrees, and why should I use them?

Git worktrees let developers check out multiple branches simultaneously in separate directories, avoiding the stash-and-switch cycle. They preserve editor state, reduce context-switching friction, and make parallel work—especially AI-assisted development—much easier. Their main drawbacks are dependency duplication, folder cleanup, and restrictions on checking out the same branch twice. ## Switching Contexts with Branches and Stashing - Traditional urgent-work flow often requires: - Stashing unfinished changes. - Checking out and updating `main`. - Creating a hotfix branch. - Committing, pushing, and merging the fix. - Returning to the original branch and restoring the stash. - This process creates mental overhead and may involve reloading files, reinstalling dependencies, or resolving stash conflicts. - Some developers compensate with multiple repository clones or increasingly complex stash commands. ## Working in Parallel with Worktrees - A worktree creates another working directory connected to the same Git repository: ```bash git worktree add ../hotfix-workspace -b hotfix-bug main ``` - The original feature branch and editor remain untouched while the hotfix is developed in a separate folder. - After merging, the temporary worktree can be removed: ```bash git worktree remove ../hotfix-workspace ``` - Worktrees eliminate stash conflicts and support truly parallel development. - Tools such as VS Code provide built-in worktree support. ## Why Worktrees Are More Popular Now - Worktrees have existed since 2015 but were historically overlooked because Git GUIs offered limited support. - Developers increasingly run multiple tasks, coding sessions, reviews, and AI agents simultaneously. - Modern tools, including the GitHub Copilot app, use worktrees as a default way to isolate parallel sessions. ## Limitations to Consider - **Dependency bloat:** Each worktree may contain its own `node_modules`, Python packages, or other dependencies. - **Folder management:** Temporary worktrees must be deleted to prevent clutter. - **`.gitignore` concerns:** Worktrees created inside the repository may need to be ignored; placing them outside the repository avoids this issue. - **One-branch restriction:** Git prevents the same branch from being checked out in multiple worktrees simultaneously. ## Worktrees in the GitHub Copilot App - New Copilot sessions can be created in a new worktree by default. - The app displays the generated worktree name, location, associated project, and changes. - Worktree management is integrated into the session workflow. Worktrees are especially useful for parallel development and AI-assisted workflows, but they are not mandatory. Developers can use worktrees, traditional branching and stashing, or a combination depending on their workflow and resource constraints.

Read original(opens in new tab)
naver1 min readCurated summary

Replacing SaaS: Building an Ad SDK Error Monitoring System with AI

The provided content does not contain a substantive tech blog post. It is a navigation listing for NAVER’s D2 platform, followed by a copyright notice. ## NAVER D2 Navigation - Hello world - D2 News - About D2 - NAVER Developers - DEVIEW - OpenSource - D2 STARTUP FACTORY ## Copyright - Copyright © NAVER Corp. All Rights Reserved. No technical argument, analysis, or conclusion is included.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Cloudflare DMARC Management is now generally available

Cloudflare DMARC Management is now generally available as a free service for Cloudflare customers. Its redesigned dashboard helps organizations understand email authentication, investigate sending sources, and safely move from monitoring to full DMARC enforcement. The goal is to reduce spoofing and improve deliverability without requiring consultants or manual XML report analysis. ## Why Email Authentication Matters - **SPF** identifies the servers and services authorized to send mail for a domain. - **DKIM** adds a cryptographic signature so recipients can verify message integrity. - **DMARC** combines SPF and DKIM results and determines whether failed messages should be delivered, quarantined, or rejected. - **BIMI** can display a brand logo in supported inboxes when a domain has a sufficiently strong DMARC policy. - Correctly configured records help block spoofed messages and improve legitimate email delivery. ## DMARC Has Become Essential - Google, Microsoft, and Yahoo have introduced stricter authentication requirements. - Domains with missing or incorrect SPF, DKIM, or DMARC records increasingly face spam placement or outright rejection. - Poor email authentication can lead to brand impersonation, missed communications, and lost revenue. ## The Risks of Reaching Enforcement - DMARC policies typically progress from: - `p=none`: monitor activity without blocking messages - `p=quarantine`: send suspicious messages to spam - `p=reject`: block unauthenticated messages - Tightening the policy too quickly can disrupt legitimate mail from forgotten third-party services. - Moving too slowly leaves the domain vulnerable to spoofing and deliverability problems. - Organizations must analyze aggregate XML reports and identify every legitimate sending source before enforcing stricter policies. ## Deeper Report Visibility and Source Investigation - Reports now show: - Source IP addresses - Sending service names - DMARC, SPF, and DKIM alignment results - Users can open an IP address in Cloudflare’s Investigate tab to view: - Reputation data - Geolocation - ASN information - Known malicious associations - This turns DMARC reports into an investigation tool for distinguishing legitimate infrastructure from unauthorized senders. ## Unified Authentication Record Status - A single view reports the status of DMARC, DKIM, SPF, and BIMI records. - Each record receives a pass, warning, or fail result based on automated analysis. - The dashboard identifies issues such as: - Multiple SPF records - SPF lookup-limit problems - Permissive `+all` settings - Missing SPF mechanisms - Malformed DKIM keys - Missing BIMI records when the domain qualifies for one - Recommendations are presented in plain language with actionable remediation steps. Cloudflare’s recommendation is effectively to use DMARC Management to identify all sending sources, correct authentication records, and gradually move toward `p=reject` with greater confidence and less risk of interrupting legitimate email.

Read original(opens in new tab)
figma2 min readCurated summary

4 Ways We’re Using Our MCP Server at Figma | Figma Blog

Figma’s MCP server has expanded beyond design-to-code workflows to support Slides, FigJam, Figma Make, and the Figma design agent. The post argues that agents can now create and update production-ready artifacts while preserving team context, design systems, custom fonts, and brand consistency. In practice, humans still provide review and polish, but agents can complete much of the initial content and formatting work. ## Broader MCP capabilities - Agents can create or update: - Figma Slides presentations - FigJam boards - Figma Make prototypes - Canvas designs through the Figma agent - The server supports: - Custom fonts uploaded from a user’s computer - Downloading assets as SVG, PDF, JPG, or PNG through `download_assets` - Reusable MCP skills that encode team decisions and workflows - These capabilities connect external context and coding tools with Figma’s design environment. ## Creating and refreshing Figma Slides decks - Designer advocate Mallory Dean maintains an evergreen deck about Figma’s AI product launches. - She prompted an agent to: - Update the deck with the new Figma agent - Gather information from Slack, Google Drive, Shortcut blog posts, and release notes - Suggest content updates and new slides - The agent used the `use_figma` tool and `/figma-use-slides` skill to modify the existing deck template. - The first 80% of the content work was completed before human review. - Mallory still needed to replace images, edit copy, and approve the final slides. - Uploaded custom fonts allowed the deck to use the correct brand typefaces rather than web-safe substitutes. - Similar workflows can support: - Product kickoff decks - Design explorations - Go-to-market presentations - Sales decks with current product information - The stated benefit is faster production of presentations that remain aligned with a team’s design system and brand. ## Generating FigJam boards from live data - Product manager Prasant Lokinendi frequently prepares feature kickoff workshops. - Building an engaging FigJam board requires collecting company context and formatting the board for each session. - To streamline this process, he created the `/figjam-builder` skill. - Figma describes skills as a way to make agent outputs more consistent and context-aware. - Teams can use community-created skills or submit their own through Figma’s community-resources repository. Figma’s MCP workflows are most useful for accelerating repetitive preparation and production work while leaving humans responsible for review, judgment, and final creative decisions.

Read original(opens in new tab)
toss4 min readCurated summary

Why the Designer Built an App Instead of a Mockup

AI is changing design by letting designers create working prototypes rather than only static mockups. While building Toss’s “underlay” component, the author used SwiftUI, AI, and Metal shaders to design interactions directly on an iPhone. The experience reduced the translation gap between design and development and showed that a functional code prototype can become a more accurate specification than a traditional design document. ## Turning End Screens into New Starting Points - Toss identified screens that appear after users finish tasks, such as completing a transfer or payment. - These “dead ends” usually signal the end of an experience and encourage users to leave the app. - The project aimed to turn them into starting points for new experiences through a reusable component that could work throughout the app. ## The Idea Behind Underlay - Existing notification patterns—bottom sheets, toasts, push notifications, and overlays—attract attention but can interrupt what users are doing. - The author found inspiration in removing a shipping label from a moving box and revealing text that had already existed underneath. - This led to the concept of an **underlay**: instead of placing new information on top of the current screen, the component reveals something beneath it. - The component needed to be recognizable as a feature, preserve the existing experience, and remain reusable across the app. ## Designing Interaction with AI and Code - Figma prototypes showed that underlay’s movement mattered more than its static appearance. - Without experience in Protopie or Framer, the author built an iOS playground in SwiftUI using Xcode and AI. - The designer’s role was to: - Describe the intended experience - Select the best options proposed by AI - Evaluate the result on a real device - The process became a cycle of designing, choosing, testing, and refining. ## Building and Refining the Prototype - The author first created a personal playground for quickly experimenting with layouts, buttons, and text. - Each change was tested through actual device interaction rather than static previews. - The prototype was revised hundreds of times because imagined motion often felt different once implemented. - A scanning-light interaction was created to suggest that AI was reading the screen and finding relevant information. - The visual effect used a Metal shader to control pixel-level properties such as: - Light diffusion - Tint and width - Movement speed - Background darkening - The author gradually began adjusting shader values directly, despite having no prior shader or interaction-tool experience. ## Replacing Interaction Guidelines with a Repository - Instead of preparing a detailed document specifying timing, easing curves, and delays, the author gave developers the working prototype repository. - The developers reproduced the core structure almost immediately because they could inspect and run the implementation directly. - During refinement, the designer adjusted values and interactions directly on the developer’s laptop with AI. - A working reference made communication more precise than phrases such as “the motion feels wrong.” - Both the AI and developers could respond to the same concrete behavior rather than interpreting abstract descriptions. ## Designing the Implementation Structure - The production iOS code ended up closely resembling the prototype’s structure. - This happened because the author had built the prototype for rapid user testing and iteration, not specifically for production. - A well-structured prototype allowed design changes to be communicated through code and reused during implementation. - The article argues that a good design is not only visually convincing; its underlying construction should also be viable. - When a prototype is built in a development-ready way, it can function as the specification rather than disposable code. ## Applying the Approach - Start with the best possible experience instead of limiting ideas to what a familiar design tool can express. - Use AI and code to create a working artifact, since real devices reveal details and textures static tools may hide. - When handing off complex interactions, provide executable code or a repository instead of relying solely on written guidelines. - As AI handles more of the “how,” designers increasingly differentiate themselves through what they choose to imagine and build.

Read original(opens in new tab)
google3 min readCurated summary

From pixels to planning: Earth AI for nature restoration

Google Research developed a high-resolution AI system that converts satellite imagery into vector data identifying small ecological features such as hedgerows, stone walls, and copses. These features can store carbon and support biodiversity without taking agricultural land out of production, but they are often missed by conventional forest inventories. The resulting open dataset aims to make fine-scale nature restoration measurable and actionable across the UK. ## The case for fine-scale restoration - Forests support carbon sequestration, water filtration, and biodiversity, but expanding forests can compete with food production. - Conservation efforts can also create “leakage,” shifting environmental damage elsewhere. - Hedgerows, shelterbelts, and other woody features offer ecological benefits while remaining integrated into farmland. - Google’s earlier **Farmscapes 2020** raster map detected these features across England, but pixel data was insufficient for planning, restoration, and carbon accounting. ## Challenges in mapping the countryside - Agricultural features often overlap spatially, such as hedgerows growing alongside or over stone walls. - Processing data in S2-cell tiles can split features at tile boundaries. - A generic “woody” classification does not reveal whether a feature is a forest, wildlife corridor, or isolated copse. - England’s more than 130,000 km² of high-resolution imagery created major computational demands for conventional raster-to-vector processing. ## Deep learning and vectorization - The team fine-tuned Remote Sensing Foundations’ Vision Transformer, pretrained on more than 300 million global satellite images. - Only about 247 km² of annotated British landscape data was available, so the pretrained model helped transfer broad visual knowledge to local conditions. - A dual-layer labeling system combined submeter imagery with 1-meter LiDAR to distinguish: - Ground-level boundaries such as fields and water - Above-ground features such as trees and walls - Geometry-merging algorithms reconnected features split across S2-cell borders. ## Classifying ecological features - The system used the **Polsby–Popper compactness score** to classify detected shapes by geometry. - Woodlands were defined as contiguous canopies at least 30 meters in diameter. - Woody patches included small copses and individual trees. - Linear woody features, including hedgerows and corridors, were identified using a compactness score below 0.5. - This classification turns raw detections into an inventory tied more closely to ecological function. ## Scaling the analysis - Google Earth Engine processed thousands of S2 cells in parallel. - This made it possible to generate vector geometries for millions of features across England without overwhelming traditional systems. - The resulting dataset is intended for landowners, conservationists, scientists, and policymakers. ## Future applications - The researchers plan to apply the method to silvopasture and agrisilviculture. - High-precision monitoring could help detect conservation “leakage” beyond project boundaries. - Open access to the data could support restoration while protecting agricultural productivity and food security. The dataset provides a practical foundation for planning and measuring nature recovery on working lands, demonstrating how AI can translate overlooked landscape details into conservation decisions.

Read original(opens in new tab)
toss4 min readCurated summary

User Segmentation for Understanding 28 Million MAU, TUES

Toss developed TUES (Toss User Engagement Segment) to analyze its 28 million monthly active users from a platform-wide perspective. It groups users by their service-use patterns, enabling Toss to understand user motivations, design segment-specific strategies, and explain changes in company-wide metrics. TUES V2 improves on the original by capturing usage depth, multi-service behavior, and engagement with individual service categories. ## Platform-Wide User Segmentation - Service-specific segments such as “users of Service A” are not mutually exclusive or collectively exhaustive because users may use multiple services. - TUES groups users with similar patterns across Toss’s entire service ecosystem. - It helps identify: - Which services users primarily use - How engaged they are with the app - Which user groups may be suitable for particular growth or marketing strategies ## How TUES V1 Worked - Toss calculated each user’s service-use rate per app open. - For example, a user who opened the app 60 times and used Toss Pay during 20 of those sessions had a 33% usage rate. - Users with similar service-usage distributions were grouped using K-Means clustering. - The raw clusters were interpreted and renamed to make them more useful for product and strategy teams. - V1 included: - **Highly engaged users:** Users who regularly use several services - **Service-oriented users:** Users primarily focused on Toss Bank, Toss Securities, inquiry services, benefits, transfers, or other services - **Simple visitors:** Users who open the app but rarely use its services ## How Toss Uses TUES - **Transition strategy:** Teams can plan how to move users from simple visits to service-oriented engagement and eventually to highly engaged usage. - **Product growth:** Product teams can quickly identify which user segments use their service most and combine that insight with transition strategies. - **Behavior analysis:** TUES reveals when users change segments, begin churning, or return after inactivity. - **Top-line metric analysis:** When MAU changes, Toss can identify which user segments moved and which services likely caused the change. - **Targeted marketing:** Marketers use TUES segments for campaigns such as push notifications. The segments are also available in Toss’s internal marketing tool, TUBA. ## Limitations of TUES V1 After roughly two years of use, Toss identified several weaknesses: - V1 measured only the probability of using a service during an app open, not the number of times it was used. - Users who engaged with a service once and users who used it ten times could appear equivalent. - It could not show engagement with secondary service categories. - K-Means is a hard-clustering method, so each user belonged to only one segment despite often using multiple services. - New major services, including Toss Shopping, App in Toss, and Toss Pay, were grouped into a generic “ETC” category. ## TUES V2 Improvements - **Usage-depth measurement:** V2 uses the number of service interactions per app open as a feature, capturing the intensity of engagement. - **Soft clustering:** Instead of assigning each user to one segment, V2 calculates each user’s degree of association with multiple segments and selectively uses those results. - **Three-layer structure:** Users are described through: 1. Overall app engagement 2. Primary service orientation 3. Engagement with each individual service category - The layers are built sequentially, making it clearer why a user belongs to a segment and what action may be appropriate next. ## New Strategic Capabilities in V2 - Teams can identify which service-category engagement should increase first to move users from a semi-engaged segment to a highly engaged one. - Individual service teams, or silos, can quantitatively connect actions that increase service engagement with company-wide segment and performance changes. - Products can more clearly compare the engagement profiles of users who do and do not use their services. - Cross-activation strategies now have a more precise starting point based on service-level engagement. ## Future Development Toss plans to combine TUES with additional analytical frameworks to: - Create faster and more detailed transition strategies using concepts such as service similarity. - Build strategic user maps based on user profiles and service-use patterns. - Quantify segment-specific value by combining TUES with frameworks such as MTVi. TUES demonstrates how platform-level segmentation can make a growing MAU base easier to understand and act upon. By combining overall engagement, primary service use, and service-level depth, TUES helps Toss develop more targeted growth strategies and connect individual product actions to broader company outcomes.

Read original(opens in new tab)
aws4 min readCurated summary

AWS WAF adds AI traffic monetization capability to help content owners charge AI bots for content access | Amazon Web Services

AWS WAF introduces AI traffic monetization, allowing publishers to charge AI bots for content access at the network edge. Owners can set prices and access rules by content path and agent verification tier without changing origin infrastructure or building payment systems. The capability uses stablecoin payments and the x402 protocol, helping publishers recover costs from AI traffic that generates little referral value. ## Why AI Traffic Monetization Matters - AI crawlers now represent more than half of web traffic for many content providers. - AI-specific crawler activity has reportedly grown over 300% year over year. - Unlike search crawlers, AI agents often consume content without sending users back to the publisher. - Publishers still pay for bandwidth and infrastructure while losing potential page views, advertising impressions, and subscriptions. - AWS WAF Bot Control previously supported visibility, blocking, and rate limiting, but not payment collection. ## Setting Up a Protection Pack - AWS WAF Bot Control must be enabled at the Common or Targeted level on the web ACL associated with a CloudFront distribution. - A protection pack defines: - Monetized content paths - Pricing by agent verification tier - Accepted payment methods - License terms - Protection packs can be created in the AWS WAF and Shield console. - Users can associate CloudFront distributions, select managed security protections, and customize monetization settings. - Multiple protection packs can apply different pricing policies to separate content zones. ## Analyzing AI Bot Traffic - The AI traffic analysis dashboard divides requests into: - All bot requests - AI bot requests - Verified AI bot traffic - Unverified AI bot traffic - It reports bandwidth usage, estimated monthly cost, and peak request rates. - A per-path heatmap shows when and where AI agents access content. - AWS WAF Bot Control classifies more than 650 AI bot and agent types, including GPTBot, Claude-Web, and Perplexity-Bot. ## Agent Verification Tiers - **Verified:** Identity is confirmed through Web Bot Auth Ed25519 signatures or documented IP ranges with known user-agent and domain information. - **Unverified:** The agent is identified using user-agent matching, behavioral fingerprints, and IP reputation, but lacks cryptographic confirmation. ## Access and Pricing Actions For each verification tier, publishers can choose one of six actions: - **Monetize:** Charge for access and return an HTTP 402 response. - **Allow:** Provide free access. - **Block:** Deny the request. - **Count:** Log the request without charging. - **CAPTCHA:** Require human verification. - **Challenge:** Silently verify that the client is a browser rather than a bot. ## Stablecoin Payments and x402 - Publishers select supported blockchain networks and provide a wallet address. - Pricing is set as a base page price in USDC, with support for multiple networks. - AWS does not process payments or take a share of content revenue; settlement is handled by the publisher or wallet provider. - Monetized requests return an HTTP 402 response containing an x402 JSON price manifest. - The manifest specifies: - USDC price - Accepted networks, such as Base and Solana - Destination wallet - Payment timeout - Payment scheme - Compatible AI agents can submit signed payment authorizations autonomously. - AWS WAF verifies the payment, uses third-party facilitators such as Coinbase’s x402 Facilitator for on-chain settlement, retrieves the content, and returns it to the agent. ## Deployment Limits and Testing - Monetization rules are supported only on web ACLs associated with Amazon CloudFront distributions. - Regional web ACLs cannot use the Monetize action. - Real and Test currency modes can be switched from the monetization configuration page. - Test mode is intended for validating pricing, wallet settings, and x402 payment flows before production deployment. - Stripe account payments and Machine Payments Protocol support are planned for future releases. Publishers should first enable Bot Control and study AI traffic patterns before setting prices. Protection packs and test mode provide a way to apply differentiated policies while validating that automated payment and content delivery work correctly.

Read original(opens in new tab)
github2 min readCurated summary

GitHub Copilot CLI for Beginners: Overview of common slash commands

GitHub Copilot CLI’s slash commands provide a central way to control sessions directly from the terminal. They help users select models, manage context, inspect changes, switch projects, resume work, and control permissions. The article recommends typing `/` to explore the available commands and build a more deliberate CLI workflow. ## Slash Commands as Copilot CLI Controls - Slash commands are built-in terminal controls for: - Guiding Copilot’s behavior - Inspecting project changes - Managing conversation context - Moving between sessions and repositories - Resetting tool permissions - Typing `/` displays a scrollable list of supported commands. ## Selecting a Model - `/model` opens the list of available models. - Model information includes: - Capabilities for lightweight tasks or deeper reasoning - Availability based on the user’s plan or organization - Cost multipliers indicating relative usage cost - Choosing an appropriate model can balance speed, quality, and cost. ## Managing Context and Tokens - `/context` shows remaining tokens, system usage, and available buffer. - `/compact` summarizes the current conversation to free context space without starting over. - Copilot may compact automatically near the context limit, but users can trigger it manually when changing tasks. - `/clear` completely resets the current session. ## Resuming Previous Sessions - `/resume` lists earlier local and remote sessions. - Users can select a session to review its history and continue where they left off. ## Reviewing Changes - `/diff` displays recent modifications made during the session. - This helps users inspect and validate Copilot’s changes before proceeding. ## Switching Projects - `/cwd` changes Copilot’s current working directory. - It allows users to move between repositories or project directories without exiting the CLI. ## Resetting Permissions - `/reset-allowed-tools` removes previously granted permissions for actions such as editing files. - This is useful when switching to a repository that requires more cautious access controls. Users should start by typing `/` in Copilot CLI to discover available commands, then use commands such as `/model`, `/context`, `/compact`, `/diff`, and `/cwd` to maintain control over their coding sessions.

Read original(opens in new tab)
github3 min readCurated summary

Accelerating researchers and developers building multilingual AI with a new open dataset

GitHub has released the GitHub Multilingual Repositories Dataset, an open metadata resource for finding public repositories containing non-English developer content. Covering more than 40 million repositories, it classifies language use in READMEs, issues, and pull requests, helping researchers build multilingual AI tools and study representation in open source. GitHub emphasizes that the dataset is a discovery tool—not definitive language ground truth—and releases it under CC0-1.0. ## Dataset Scope and Contents - Contains over 80 million classification rows across more than 40 million public repositories. - Classifies: - READMEs - The most-commented issue - The most-commented pull request - Uses the first 150 characters of each text source, excluding samples shorter than 20 characters. - Includes classifications and confidence scores from: - fastText - Google’s CLD3 - lingua-py - Only classifications with confidence above 0.5 are included. - Repository metadata includes creation date, disk usage, stars, forks, primary language, SPDX license, issue and pull request counts, and snapshot date. ## Why Multiple Classifiers Are Exposed - GitHub does not combine the three classifiers into one definitive language label. - Classifiers differ in language coverage and confidence calibration, particularly for lower-resource languages. - Users can choose their own precision and recall strategy: - Require agreement among all classifiers for high-precision research. - Use a single classifier for broader exploratory studies. ## Language Patterns in Developer Content - Language distribution varies by repository content type. - Korean is the most common non-English language in issue text but ranks only fifth in README classifications. - Portuguese is the leading non-English README language, appearing in more than 3 million repositories. - These differences show that developer communities may use different languages for documentation, issue discussions, and code collaboration. ## Potential Applications - Find repositories with documentation or collaboration in particular languages. - Study how multilingual communities use READMEs, issues, and pull requests. - Create evaluation datasets for coding assistants, documentation generators, and code review tools. - Measure representation of European and other underrepresented languages in open source. - Provide evidence for expanding language support in developer tools and AI systems. ## Limitations and Responsible Use - Repository text is often short and may contain badges, commands, code, usernames, templates, or multiple languages. - A 150-character sample may not represent the language of an entire repository. - Classifier performance varies, especially for lower-resource languages. - The dataset should not be treated as a ground-truth language-identification benchmark. - It provides repository-level signals and should not be used to infer sensitive characteristics of repository owners, contributors, or communities. ## Importance for Multilingual AI - Many European languages are underrepresented in the data used to train and evaluate AI systems. - Developer content provides domain-specific examples of software collaboration, including installation guidance, bug reports, feature requests, and code reviews. - The dataset can help identify language gaps, improve evaluation, and support more inclusive AI tools for developers worldwide. GitHub recommends using the CC0-licensed dataset to conduct research, build evaluation sets, develop tools, and improve its classifications. Its transparency and multiple confidence signals allow users to tailor the data to their own research needs while accounting for its limitations.

Read original(opens in new tab)
kakao4 min readCurated summary

Automating KakaoTalk Recommendation Metric Analysis with an AI Agent

The post describes Kakao’s use of an AI agent to automate repetitive analysis of KakaoTalk recommendation metrics on an existing Hadoop environment. Rather than building a new platform or granting the model broad permissions, the team documented existing procedures, data definitions, and decision rules in Markdown-based agent skills and context files. The resulting system helps analysts produce draft reports and explore follow-up questions, while humans remain responsible for validating results and making final decisions. ## Repetitive Analysis Is an Ideal Automation Target - Recommendation analysis often begins with simple questions about CTR changes, experiments, or user-group anomalies. - Answering them typically requires: - Connecting to the analysis environment - Finding the right tables - Writing and executing queries - Interpreting results - Repeating the process across dimensions such as age, category, and time - Much of the effort lies in data preparation and extraction rather than interpretation. - The initial goal was for the AI to follow these steps and produce a first-pass analysis without requiring users to handle queries directly. ## Teaching the Agent to Use Hadoop - The team did not build a new analytics platform or add an MCP integration layer. - Existing Hadoop access scripts were sufficient; the missing component was documentation explaining how to use them. - These procedures were packaged as Agent Skills—Markdown files such as `SKILL.md` describing: - How to connect to Hadoop - How to submit queries - How to retrieve and organize results - The `hadoop-butler` plugin bundled these skills for internal use. - The main lesson was that existing infrastructure can often be extended by converting undocumented operational knowledge into instructions an agent can follow. ## Context Documents Improve Analytical Accuracy - Access to data does not guarantee correct analysis. - Context files such as `CLAUDE.md` or `AGENTS.md` documented: - Relevant tables and clusters - Feature definitions, such as `watch_length` and `valid_view` - User and session aggregation rules - Standard metric definitions - This prevented the agent from repeatedly guessing which tables, columns, or aggregation rules to use. - The documentation also captured institutional knowledge that could help new team members, not only AI systems. - Output quality was determined by the quality and precision of the available context. ## AI Produces Drafts; Analysts Continue the Investigation - Natural-language analysis was most useful for recurring tasks such as: - Detecting anomalies - Comparing experiments - Reviewing weekly performance - The agent’s first report helped identify areas for deeper investigation. - Analysts could then ask follow-up questions and refine the analysis conversationally. - AI-generated reports were treated as reviewable drafts, not final conclusions. - Query logic, selected columns, metric definitions, and interpretations still required human verification. ## Plausible but Incorrect Results The agent’s most dangerous errors were not syntax failures; they were queries that executed successfully but produced misleading results. - **Semantic errors** - To count users, the correct field was `user_id`. - The agent once selected the similarly named `session_user_id`, which represented a session-oriented identifier. - The query ran normally, but the resulting user count was wrong. - **Performance errors** - The agent combined several `COUNT(DISTINCT ...)` expressions in one Hive query. - Although valid SQL, this could force processing through a single reducer and make the query extremely slow. - The better approach was to split the calculations by column and run them in parallel. ## Documentation and Regression Testing - Explicit rules were added to context files and skills, including: - Which identifier to use for user-level aggregation - Wrapping column names in backticks - Splitting multiple `COUNT(DISTINCT)` operations into separate queries - Because natural-language instructions can break other behaviors when modified, the team tested them like software. - An MLflow-based end-to-end evaluation pipeline: - Defines expected behavior for each skill - Runs the agent headlessly with `claude -p` - Uses an LLM judge to evaluate tool-call order, execution traces, and final output - Runs regression scenarios before deployment - This made it possible to catch unintended behavior changes before release. The recommended architecture combines four elements: an AI model, precise domain context, an existing execution environment such as Hadoop, and a verification loop. Organizations should first document their established procedures and analytical definitions, then connect the agent to existing tools and test its behavior systematically.

Read original(opens in new tab)