Why SVG?

SVG is a great fit for AI-generated graphics — it’s just text, so the model can reason about coordinates and structure without hallucinating pixel values. The output is infinitely scalable, easy to inspect, and works anywhere a browser does.

The Three Skills

svg-logo

Generates a 100×100 icon-only logo mark. No text, no external fonts. The safe zone is 6–94px on each axis so the mark survives cropping to any shape.

Inputs collected before generation:

• Style — Geometric, Lettermark, Abstract mark, or Mascot/character
• Palette — six presets (Midnight, Ember, Moss, Steel, Blush, Obsidian), each a primary + accent pair
• Animation — None, Entrance (fade/scale), Loop (breathe/pulse), or Spin

The design constraint of 1–2 colors and geometric primitives only (<circle>, <rect>, <polygon>, <path>) keeps logos legible at 50px while still looking intentional.

Example output: outputs/brew-logo.svg

svg-illustration

Generates expressive, layered illustrations with a default 400×300 canvas (wide banner, portrait, and square also available). Every output is structured into three named groups — #background, #midground, #foreground — so the layers are easy to edit afterward.

Inputs collected before generation:

• Style — Flat, Outlined, Isometric, or Organic
• Palette — six presets (Aurora, Meadow, Dusk, Sand, Coral, Arctic)
• Canvas size
• Animation — None, Float, Fade in layers, or One element loops

Color discipline: max 5 distinct hues total, opacity variations before introducing new colors. The background layer is always the palette’s background color; accent colors go on the foreground focal element only.

SMIL and CSS @keyframes are used for animation — no JavaScript, fully portable.

Example output: outputs/developer-coding-illustration.svg

svg-flowchart

Generates structured process diagrams with a fixed 800px width and computed height based on node count. Handles four diagram types — Linear steps, Decision tree, Swimlane, and Cycle/loop — in either Top→Bottom or Left→Right orientation.

Inputs collected before generation:

• Diagram type — Linear, Decision tree (with branches), Swimlane (by role/team), or Cycle/loop
• Direction — Top→Bottom or Left→Right
• Palette — five presets (Indigo, Ocean, Slate, Violet, Mono)

Node shapes follow flowchart conventions: rounded rect for process steps, diamond for decisions, pill for start/end, parallelogram for input/output. Connectors always use an <marker> arrow defined in <defs> so arrowheads render correctly everywhere.

For decision branches, Yes/No labels sit on the connector line mid-point; branches reconnect back to the main axis via <path> curves.

Example output: outputs/login-process-flowchart.svg

Common Design Decisions

A few things I applied consistently across all three skills:

Ask first, generate once. Each skill uses ask_user_input_v0 to collect style and color options before emitting any SVG. This eliminates the back-and-forth of “regenerate but make it darker.”

Palette presets over free-form colors. Offering named palettes with pre-paired colors produces more harmonious results than letting users specify arbitrary hex codes.

No external resources. No <image> tags, no Google Fonts, no CDN links. The output file is always fully self-contained.

Outputs go to ./outputs/ with a descriptive filename like login-process-flowchart.svg. Predictable output paths make it easy to drop the file into a project without renaming.

Introduction

Ganache is a local development blockchain used to develop decentralized applications on the Ethereum blockchain. It simulates the Ethereum network, and you can see how your DApp will perform before you release it to production.

By default, Ganache provides 10 test accounts, each with 1000 (fake) Ether along with the corresponding private keys and the mnemonic phrase used to generate them. As a result, we can deploy our smart contract to local blockchain to test with those fake Ether. It is convinient to use.

Note: Community no longer support :(

Installation

1. install via image: https://trufflesuite.com/ganache/
2. install & run via cli:

   npm install ganache
   ganache
   

prerequiste: Node.js >= v12.0.0 and NPM >= 6.4.1

Hardhat

1. install the hardhat in the project:

   yarn add hardhat
   

2. In addition to ganache, hardhat also provides a way to start a local ethereum node

   npx hardhat node
   

IPFS

install ipfs locally:

wget https://dist.ipfs.io/go-ipfs/v0.4.18/go-ipfs_v0.4.18_linux-amd64.tar.gz
tar xvfz go-ipfs_v0.4.18_linux-amd64.tar.gz
sudo mv go ipfs/ipfs /usr/local/bin/ipfs
ipfs init
ipfs version

Example

Step 1: switch to use node 18:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash 
nvm install 18 
nvm use 18 
nvm alias default 18 
npm install npm --global # Upgrade npm to the latest version

Step 2: init a project:

mkdir <yourprojectname> && cd <yourprojectname>
yarn init
yarn add --dev hardhat
npx hardhat

Step 3: install plugins:

yarn add --dev @nomicfoundation/hardhat-toolbox @nomicfoundation/hardhat-network-helpers @nomicfoundation/hardhat-chai-matchers @nomiclabs/hardhat-ethers @nomiclabs/hardhat-etherscan chai ethers hardhat-gas-reporter solidity-coverage @typechain/hardhat typechain @typechain/ethers-v5 @ethersproject/abi @ethersproject/providers

Step4: compile sample smart contract

npx hardhat compile

Step 5: run deployment script

npx hardhat run scripts/deploy.ts

You might have error below:

#HH303: Unrecognized task

so downgrade ethers version to ^5.4.7 and rerun.

You will get the successful result like this: ![[npx hardhat run command.png]]

Alternatively

Foundry

curl -L https://foundry.paradigm.xyz | bash

foundryup

Basic Concepts

• private key
• public key
• address

Private Key

In Ethereum, private key is a random 256-bit (64 hexadecimal characters) secure number that provides the owner access to its associated account. A private key is used for signing transactions, which is a cryptographic process of verifying the transaction. With a private key, the owner can initiate transactions, send and receive Ether, and interact with smart contracts on the Ethereum network.

A private key example (please don’t use this one):

0101001011110110000110001001001010110010000000101110111011010011000101011001010000001101011011001000000010000001100101101011001101010101011001111000011010111010110100011010111111010110111001001000100010010010101111111100001101110101101100100100011011110000 

Public Key

A public key is derived from the corresponding private key using a mathematical algorithm. The private key is used to generate a digital signature for a transaction, while the public key is used to verify the transaction signature. The public key is derived from the private key using a mathematical process that cannot be reversed, which ensures that a private key cannot be derived from a public key.

A public key is composed of two parts: an X-coordinate and a Y-coordinate, both of which are represented by 64 hexadecimal characters (256 bits).

Elliptic Curve Cryptography

The mathematical algorithm used to derive a public key from a private key in Ethereum is called Elliptic Curve Cryptography (ECC).

In the case of Ethereum, the elliptic curve used is called secp256k1. The secp256k1 curve is defined by the following equation:

In this equation, x and y are the coordinates of a point on the curve. The curve is defined over the field of integers modulo a prime number p, where:

The result of the multiplication of the curve’s generator point and the private key is a point on the curve, which represents the public key. This point is then compressed into a 33-byte hexadecimal string that starts with “0x02” or “0x03” depending on whether the Y-coordinate of the point is even or odd. The compressed form of the public key can be used in Ethereum transactions for verification purposes.

Address

In Ethereum, an address is a 40 hexadecimal characters (160 bits) string that represents a unique identity on the network. The address is derived from the corresponding public key of an account using Keccak-256 hash function and then truncated to create a 160-bit address, represented as a 40 hexadecimal characters. The first 2 characters of the address represent the network identifier, while the remaining 38 characters represent the unique identifier of the account.

Multi-Party Computation

In short, Multi-party computation(MPC) refers to cryptographic technique that enables different parties to joinly perform computation on their individual inputs without actually revealing their inputs to each other. One of the famous example is Yao’s Millionaires’ Problem[1] which allows two parties to determine which of them has more wealth without revealing any snesitive information about their actual wealth to each other or anyone else.

MPC can be used in many domains. But here we will focus on the usage on blockchain key management - multi-party threshold ECDSA.

There are many open-source algorithms implementing the threshold signature schemes. For examples:

To understand how multi-party threshold ECDSA works by taking an example on GG18.

Basic arithmetic concepts

Modular arithmetic

Give two integers a, b, if take a natural number (p) from a, b and the remainder are the same, then we say $a \equiv b (mod p)$

Primitive root modulo n [2]

It is mainly used to convert manipulation to addition.

Diffie-Hellman key exchange

TODO: add this part later

Lagrange polynomial

TODO: add this part later

Threshold signature sheme

Protocol consists two phases: sharing phase and reconstruction phase.

In the sharing phase, each player will broadcast their points. Other players uses these points to calculate the weight and value which can be used to reconstruct the private key in the next phase.

3-to-4 shares

Given a private key $u=140$, split it randomly into 4 shares $(10, 20, 50, 60)$ which $140 = 10 + 20 + 50 + 60$ and store it into 4 different db that handled by 4 servers.

Each server keeps one key share and a polynomial function $F_i = a_ix^2+b_ix+c_i \ ( a_i, b_i \in N, c_i \in {10, 20, 50, 60}, i \in {1, 2, 3, 4 })$

Take an example:

Server 1 stores polynomial function $F_1(x)= x^2+2x+10$, key share $u_1 = 10$

Server 2 stores polynomial function $F_2(x)= x^2+4x+20$, key share $u_2 = 20$

Server 3 stores polynomial function $F_3(x)= x^2+5x+50$, key share $u_3 = 50$

Server 4 stores polynomial function $F_4(x)= x^2+10x+60$, key share $u_4 = 60$

Then,

Randomly choose 4 different x. eg. $x_1=1$, $x_2 = 2$, $x_3 = 3$, $x_4 = 4$.

Calculate  from each server

From server 1, we get 4 points, $F_1(1) = 13$, $F_1(2) = 18$, $F_1(3) = 25$, $F_1(4) = 34$

Similarly, we get 4 points from server 2, 3 and 4.

Then save

$y_1 = F_1(1)+F_2(1)+F_3(1)+F_4(1) = 165$ to server 1, $198$ to server 2, $239$ to server 3, $288$ to server 4.

In the private key reconstruction section, let’s use server 1, server 2 and server 3 only.

Apply Lagrange interpolation formula in each server,

Server 1, $L_1(x) =\frac{ (x - 2)(x - 3)}{ (1- 2)(1-3)}$, and $L_1(0) = 3$, we get $u_1 = L_1(0) * y_1 = 165 * 3$

Server 2, $L_2(x) =\frac{ (x - 1)(x - 3)}{ (2- 1)(2-3)}$, and $L_2(0) = -3$, we get $u_3 = L_3(0) * y_3 = 239 * 1$

Server 3, $L_3(x) =\frac{ (x - 1)(x - 2)}{ (3- 1)(3-2)}$, and $L_3(0) = 1$, we get $u_3 = L_3(0) * y_3 = 239 * 1$

private key  \(u=L_1(0) * y_1 + L_2(0) * y_2+ L_2(0) * y_2 = 3*165+(-3)*198+1*239=140\)

In the DSA signing process,$y_{public key} = g^u$, u is the private key. since $g^u = g^{u_1+u_2+u_3} = g^{u_1} * g^{u_2} * g^{u_3}$, so it could be signed by each server and join then together in the end and will get the same result as using the private key to sign.

If user forget one key share, or the key pair leaks, we can repeat the process above to select a different polynomial function set for each server.

References

• [1] Yao’s Millionaires’ Problem
• [2] Primitive root

var vs := Both of them are used to declare the variables, but they are slight different from each other.

• var can be used at package level declaration, but := can only be used inside the function
• := can be use to redeclare the value. For example, a, b := "a", "b" even if a or b has been declared before. However, it is not allowed when using var

array vs slice

• Go considers size of the array to be part of the type of the array which means [3]int is different from [4]int. And type must be resolved at compile time not runtime time. Normally array is not recommended to use unless you know the exact size of the array at the beginning. for example in some cryptographic algorithm.
• slice has more flexibily to increase the capacity of the array.
• the length and capacity are two different concepts in slice. When the length exceeds capacity, Go will double the capacity and copy the slice to a new memory address. GC handles the original one.
• memory sharing properties in slice and array
• use copy to create a slice that independent of original

map vs set

• Go doesn’t include set, use map to simulate the behaviour of a set

shadowing variables

• if variable redeclare inside a statement with var or :=, the value remains the same as the one declared before the statement after the statement is destoryed
• install shadow (go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@latest) to detect shadow variables

Introduction

Kubeflow is a platform built on top of kubernetes, designed to simpfly the deployment of machine learning workflows on Kubernetes clusters. It provides an end-to-end machine learning ecosystem, featuring tools for building, training, deploying and scaling ML models.

Setup locally

minikube

Minikube is local Kubernetes.

Install from image:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube

Start minikube:

minikube start --cpus 4 --memory 8096 --disk-size=40g

Deploy kubeflow template to minikube cluster:

export PIPELINE_VERSION=1.8.5
kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/cluster-scoped-resources?ref=$PIPELINE_VERSION"
kubectl wait --for condition=established --timeout=60s crd/applications.app.k8s.io
kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/env/platform-agnostic-pns?ref=$PIPELINE_VERSION"

Check pods from kubleflow namespace to see the statuses of pods:

kubectl get pods -n kubeflow

Forward the network traffic

kubectl port-forward -n kubeflow svc/ml-pipeline-ui 8080:80

The kubeflow’s ui panel is available at: http://localhost:8080/

The processes take the responsibilities of

• (master node) handling API requests from kubectl
• (master node) scheduling pods to run on worker nodes
• running a pod on the worker node
• (worker node) monitoring and networking

etcd is the distributed key value database implemented based on Raft consensus mechanism that kubernetes uses to store configuration data, system state, and metadata. For example, kubectl get xyz command is read from etcd store. kubectl create will create an entry in etcd.

etcd vs. consul, which one is better?

Since etcd is just a simple distributed kv database, consul provides additional features like healthcheck and has built-in service discovery. consul is more like a solution.